1/*
2 * Copyright (C) 2005 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_PARCEL_H
18#define ANDROID_PARCEL_H
19
20#include <string>
21#include <vector>
22
23#include <cutils/native_handle.h>
24#include <nativehelper/ScopedFd.h>
25#include <utils/Errors.h>
26#include <utils/RefBase.h>
27#include <utils/String16.h>
28#include <utils/Vector.h>
29#include <utils/Flattenable.h>
30#include <linux/binder.h>
31
32#include <binder/IInterface.h>
33#include <binder/Parcelable.h>
34
35// ---------------------------------------------------------------------------
36namespace android {
37
38template <typename T> class Flattenable;
39template <typename T> class LightFlattenable;
40class IBinder;
41class IPCThreadState;
42class ProcessState;
43class String8;
44class TextOutput;
45
46class Parcel {
47    friend class IPCThreadState;
48public:
49    class ReadableBlob;
50    class WritableBlob;
51
52                        Parcel();
53                        ~Parcel();
54
55    const uint8_t*      data() const;
56    size_t              dataSize() const;
57    size_t              dataAvail() const;
58    size_t              dataPosition() const;
59    size_t              dataCapacity() const;
60
61    status_t            setDataSize(size_t size);
62    void                setDataPosition(size_t pos) const;
63    status_t            setDataCapacity(size_t size);
64
65    status_t            setData(const uint8_t* buffer, size_t len);
66
67    status_t            appendFrom(const Parcel *parcel,
68                                   size_t start, size_t len);
69
70    bool                allowFds() const;
71    bool                pushAllowFds(bool allowFds);
72    void                restoreAllowFds(bool lastValue);
73
74    bool                hasFileDescriptors() const;
75
76    // Writes the RPC header.
77    status_t            writeInterfaceToken(const String16& interface);
78
79    // Parses the RPC header, returning true if the interface name
80    // in the header matches the expected interface from the caller.
81    //
82    // Additionally, enforceInterface does part of the work of
83    // propagating the StrictMode policy mask, populating the current
84    // IPCThreadState, which as an optimization may optionally be
85    // passed in.
86    bool                enforceInterface(const String16& interface,
87                                         IPCThreadState* threadState = NULL) const;
88    bool                checkInterface(IBinder*) const;
89
90    void                freeData();
91
92private:
93    const binder_size_t* objects() const;
94
95public:
96    size_t              objectsCount() const;
97
98    status_t            errorCheck() const;
99    void                setError(status_t err);
100
101    status_t            write(const void* data, size_t len);
102    void*               writeInplace(size_t len);
103    status_t            writeUnpadded(const void* data, size_t len);
104    status_t            writeInt32(int32_t val);
105    status_t            writeUint32(uint32_t val);
106    status_t            writeInt64(int64_t val);
107    status_t            writeUint64(uint64_t val);
108    status_t            writeFloat(float val);
109    status_t            writeDouble(double val);
110    status_t            writeCString(const char* str);
111    status_t            writeString8(const String8& str);
112    status_t            writeString16(const String16& str);
113    status_t            writeString16(const std::unique_ptr<String16>& str);
114    status_t            writeString16(const char16_t* str, size_t len);
115    status_t            writeStrongBinder(const sp<IBinder>& val);
116    status_t            writeWeakBinder(const wp<IBinder>& val);
117    status_t            writeInt32Array(size_t len, const int32_t *val);
118    status_t            writeByteArray(size_t len, const uint8_t *val);
119    status_t            writeBool(bool val);
120    status_t            writeChar(char16_t val);
121    status_t            writeByte(int8_t val);
122
123    // Take a UTF8 encoded string, convert to UTF16, write it to the parcel.
124    status_t            writeUtf8AsUtf16(const std::string& str);
125    status_t            writeUtf8AsUtf16(const std::unique_ptr<std::string>& str);
126
127    status_t            writeByteVector(const std::unique_ptr<std::vector<int8_t>>& val);
128    status_t            writeByteVector(const std::vector<int8_t>& val);
129    status_t            writeByteVector(const std::unique_ptr<std::vector<uint8_t>>& val);
130    status_t            writeByteVector(const std::vector<uint8_t>& val);
131    status_t            writeInt32Vector(const std::unique_ptr<std::vector<int32_t>>& val);
132    status_t            writeInt32Vector(const std::vector<int32_t>& val);
133    status_t            writeInt64Vector(const std::unique_ptr<std::vector<int64_t>>& val);
134    status_t            writeInt64Vector(const std::vector<int64_t>& val);
135    status_t            writeFloatVector(const std::unique_ptr<std::vector<float>>& val);
136    status_t            writeFloatVector(const std::vector<float>& val);
137    status_t            writeDoubleVector(const std::unique_ptr<std::vector<double>>& val);
138    status_t            writeDoubleVector(const std::vector<double>& val);
139    status_t            writeBoolVector(const std::unique_ptr<std::vector<bool>>& val);
140    status_t            writeBoolVector(const std::vector<bool>& val);
141    status_t            writeCharVector(const std::unique_ptr<std::vector<char16_t>>& val);
142    status_t            writeCharVector(const std::vector<char16_t>& val);
143    status_t            writeString16Vector(
144                            const std::unique_ptr<std::vector<std::unique_ptr<String16>>>& val);
145    status_t            writeString16Vector(const std::vector<String16>& val);
146    status_t            writeUtf8VectorAsUtf16Vector(
147                            const std::unique_ptr<std::vector<std::unique_ptr<std::string>>>& val);
148    status_t            writeUtf8VectorAsUtf16Vector(const std::vector<std::string>& val);
149
150    status_t            writeStrongBinderVector(const std::unique_ptr<std::vector<sp<IBinder>>>& val);
151    status_t            writeStrongBinderVector(const std::vector<sp<IBinder>>& val);
152
153    template<typename T>
154    status_t            writeParcelableVector(const std::unique_ptr<std::vector<std::unique_ptr<T>>>& val);
155    template<typename T>
156    status_t            writeParcelableVector(const std::vector<T>& val);
157
158    template<typename T>
159    status_t            writeNullableParcelable(const std::unique_ptr<T>& parcelable);
160
161    status_t            writeParcelable(const Parcelable& parcelable);
162
163    template<typename T>
164    status_t            write(const Flattenable<T>& val);
165
166    template<typename T>
167    status_t            write(const LightFlattenable<T>& val);
168
169
170    // Place a native_handle into the parcel (the native_handle's file-
171    // descriptors are dup'ed, so it is safe to delete the native_handle
172    // when this function returns).
173    // Doesn't take ownership of the native_handle.
174    status_t            writeNativeHandle(const native_handle* handle);
175
176    // Place a file descriptor into the parcel.  The given fd must remain
177    // valid for the lifetime of the parcel.
178    // The Parcel does not take ownership of the given fd unless you ask it to.
179    status_t            writeFileDescriptor(int fd, bool takeOwnership = false);
180
181    // Place a file descriptor into the parcel.  A dup of the fd is made, which
182    // will be closed once the parcel is destroyed.
183    status_t            writeDupFileDescriptor(int fd);
184
185    // Place a file descriptor into the parcel.  This will not affect the
186    // semantics of the smart file descriptor. A new descriptor will be
187    // created, and will be closed when the parcel is destroyed.
188    status_t            writeUniqueFileDescriptor(
189                            const ScopedFd& fd);
190
191    // Place a vector of file desciptors into the parcel. Each descriptor is
192    // dup'd as in writeDupFileDescriptor
193    status_t            writeUniqueFileDescriptorVector(
194                            const std::unique_ptr<std::vector<ScopedFd>>& val);
195    status_t            writeUniqueFileDescriptorVector(
196                            const std::vector<ScopedFd>& val);
197
198    // Writes a blob to the parcel.
199    // If the blob is small, then it is stored in-place, otherwise it is
200    // transferred by way of an anonymous shared memory region.  Prefer sending
201    // immutable blobs if possible since they may be subsequently transferred between
202    // processes without further copying whereas mutable blobs always need to be copied.
203    // The caller should call release() on the blob after writing its contents.
204    status_t            writeBlob(size_t len, bool mutableCopy, WritableBlob* outBlob);
205
206    // Write an existing immutable blob file descriptor to the parcel.
207    // This allows the client to send the same blob to multiple processes
208    // as long as it keeps a dup of the blob file descriptor handy for later.
209    status_t            writeDupImmutableBlobFileDescriptor(int fd);
210
211    status_t            writeObject(const flat_binder_object& val, bool nullMetaData);
212
213    // Like Parcel.java's writeNoException().  Just writes a zero int32.
214    // Currently the native implementation doesn't do any of the StrictMode
215    // stack gathering and serialization that the Java implementation does.
216    status_t            writeNoException();
217
218    void                remove(size_t start, size_t amt);
219
220    status_t            read(void* outData, size_t len) const;
221    const void*         readInplace(size_t len) const;
222    int32_t             readInt32() const;
223    status_t            readInt32(int32_t *pArg) const;
224    uint32_t            readUint32() const;
225    status_t            readUint32(uint32_t *pArg) const;
226    int64_t             readInt64() const;
227    status_t            readInt64(int64_t *pArg) const;
228    uint64_t            readUint64() const;
229    status_t            readUint64(uint64_t *pArg) const;
230    float               readFloat() const;
231    status_t            readFloat(float *pArg) const;
232    double              readDouble() const;
233    status_t            readDouble(double *pArg) const;
234    intptr_t            readIntPtr() const;
235    status_t            readIntPtr(intptr_t *pArg) const;
236    bool                readBool() const;
237    status_t            readBool(bool *pArg) const;
238    char16_t            readChar() const;
239    status_t            readChar(char16_t *pArg) const;
240    int8_t              readByte() const;
241    status_t            readByte(int8_t *pArg) const;
242
243    // Read a UTF16 encoded string, convert to UTF8
244    status_t            readUtf8FromUtf16(std::string* str) const;
245    status_t            readUtf8FromUtf16(std::unique_ptr<std::string>* str) const;
246
247    const char*         readCString() const;
248    String8             readString8() const;
249    String16            readString16() const;
250    status_t            readString16(String16* pArg) const;
251    status_t            readString16(std::unique_ptr<String16>* pArg) const;
252    const char16_t*     readString16Inplace(size_t* outLen) const;
253    sp<IBinder>         readStrongBinder() const;
254    status_t            readStrongBinder(sp<IBinder>* val) const;
255    wp<IBinder>         readWeakBinder() const;
256
257    template<typename T>
258    status_t            readParcelableVector(
259                            std::unique_ptr<std::vector<std::unique_ptr<T>>>* val) const;
260    template<typename T>
261    status_t            readParcelableVector(std::vector<T>* val) const;
262
263    status_t            readParcelable(Parcelable* parcelable) const;
264
265    template<typename T>
266    status_t            readParcelable(std::unique_ptr<T>* parcelable) const;
267
268    template<typename T>
269    status_t            readStrongBinder(sp<T>* val) const;
270
271    status_t            readStrongBinderVector(std::unique_ptr<std::vector<sp<IBinder>>>* val) const;
272    status_t            readStrongBinderVector(std::vector<sp<IBinder>>* val) const;
273
274    status_t            readByteVector(std::unique_ptr<std::vector<int8_t>>* val) const;
275    status_t            readByteVector(std::vector<int8_t>* val) const;
276    status_t            readByteVector(std::unique_ptr<std::vector<uint8_t>>* val) const;
277    status_t            readByteVector(std::vector<uint8_t>* val) const;
278    status_t            readInt32Vector(std::unique_ptr<std::vector<int32_t>>* val) const;
279    status_t            readInt32Vector(std::vector<int32_t>* val) const;
280    status_t            readInt64Vector(std::unique_ptr<std::vector<int64_t>>* val) const;
281    status_t            readInt64Vector(std::vector<int64_t>* val) const;
282    status_t            readFloatVector(std::unique_ptr<std::vector<float>>* val) const;
283    status_t            readFloatVector(std::vector<float>* val) const;
284    status_t            readDoubleVector(std::unique_ptr<std::vector<double>>* val) const;
285    status_t            readDoubleVector(std::vector<double>* val) const;
286    status_t            readBoolVector(std::unique_ptr<std::vector<bool>>* val) const;
287    status_t            readBoolVector(std::vector<bool>* val) const;
288    status_t            readCharVector(std::unique_ptr<std::vector<char16_t>>* val) const;
289    status_t            readCharVector(std::vector<char16_t>* val) const;
290    status_t            readString16Vector(
291                            std::unique_ptr<std::vector<std::unique_ptr<String16>>>* val) const;
292    status_t            readString16Vector(std::vector<String16>* val) const;
293    status_t            readUtf8VectorFromUtf16Vector(
294                            std::unique_ptr<std::vector<std::unique_ptr<std::string>>>* val) const;
295    status_t            readUtf8VectorFromUtf16Vector(std::vector<std::string>* val) const;
296
297    template<typename T>
298    status_t            read(Flattenable<T>& val) const;
299
300    template<typename T>
301    status_t            read(LightFlattenable<T>& val) const;
302
303    // Like Parcel.java's readExceptionCode().  Reads the first int32
304    // off of a Parcel's header, returning 0 or the negative error
305    // code on exceptions, but also deals with skipping over rich
306    // response headers.  Callers should use this to read & parse the
307    // response headers rather than doing it by hand.
308    int32_t             readExceptionCode() const;
309
310    // Retrieve native_handle from the parcel. This returns a copy of the
311    // parcel's native_handle (the caller takes ownership). The caller
312    // must free the native_handle with native_handle_close() and
313    // native_handle_delete().
314    native_handle*     readNativeHandle() const;
315
316
317    // Retrieve a file descriptor from the parcel.  This returns the raw fd
318    // in the parcel, which you do not own -- use dup() to get your own copy.
319    int                 readFileDescriptor() const;
320
321    // Retrieve a smart file descriptor from the parcel.
322    status_t            readUniqueFileDescriptor(
323                            ScopedFd* val) const;
324
325
326    // Retrieve a vector of smart file descriptors from the parcel.
327    status_t            readUniqueFileDescriptorVector(
328                            std::unique_ptr<std::vector<ScopedFd>>* val) const;
329    status_t            readUniqueFileDescriptorVector(
330                            std::vector<ScopedFd>* val) const;
331
332    // Reads a blob from the parcel.
333    // The caller should call release() on the blob after reading its contents.
334    status_t            readBlob(size_t len, ReadableBlob* outBlob) const;
335
336    const flat_binder_object* readObject(bool nullMetaData) const;
337
338    // Explicitly close all file descriptors in the parcel.
339    void                closeFileDescriptors();
340
341    // Debugging: get metrics on current allocations.
342    static size_t       getGlobalAllocSize();
343    static size_t       getGlobalAllocCount();
344
345private:
346    typedef void        (*release_func)(Parcel* parcel,
347                                        const uint8_t* data, size_t dataSize,
348                                        const binder_size_t* objects, size_t objectsSize,
349                                        void* cookie);
350
351    uintptr_t           ipcData() const;
352    size_t              ipcDataSize() const;
353    uintptr_t           ipcObjects() const;
354    size_t              ipcObjectsCount() const;
355    void                ipcSetDataReference(const uint8_t* data, size_t dataSize,
356                                            const binder_size_t* objects, size_t objectsCount,
357                                            release_func relFunc, void* relCookie);
358
359public:
360    void                print(TextOutput& to, uint32_t flags = 0) const;
361
362private:
363                        Parcel(const Parcel& o);
364    Parcel&             operator=(const Parcel& o);
365
366    status_t            finishWrite(size_t len);
367    void                releaseObjects();
368    void                acquireObjects();
369    status_t            growData(size_t len);
370    status_t            restartWrite(size_t desired);
371    status_t            continueWrite(size_t desired);
372    status_t            writePointer(uintptr_t val);
373    status_t            readPointer(uintptr_t *pArg) const;
374    uintptr_t           readPointer() const;
375    void                freeDataNoInit();
376    void                initState();
377    void                scanForFds() const;
378
379    template<class T>
380    status_t            readAligned(T *pArg) const;
381
382    template<class T>   T readAligned() const;
383
384    template<class T>
385    status_t            writeAligned(T val);
386
387    status_t            writeRawNullableParcelable(const Parcelable*
388                                                   parcelable);
389
390    template<typename T, typename U>
391    status_t            unsafeReadTypedVector(std::vector<T>* val,
392                                              status_t(Parcel::*read_func)(U*) const) const;
393    template<typename T>
394    status_t            readNullableTypedVector(std::unique_ptr<std::vector<T>>* val,
395                                                status_t(Parcel::*read_func)(T*) const) const;
396    template<typename T>
397    status_t            readTypedVector(std::vector<T>* val,
398                                        status_t(Parcel::*read_func)(T*) const) const;
399    template<typename T, typename U>
400    status_t            unsafeWriteTypedVector(const std::vector<T>& val,
401                                               status_t(Parcel::*write_func)(U));
402    template<typename T>
403    status_t            writeNullableTypedVector(const std::unique_ptr<std::vector<T>>& val,
404                                                 status_t(Parcel::*write_func)(const T&));
405    template<typename T>
406    status_t            writeNullableTypedVector(const std::unique_ptr<std::vector<T>>& val,
407                                                 status_t(Parcel::*write_func)(T));
408    template<typename T>
409    status_t            writeTypedVector(const std::vector<T>& val,
410                                         status_t(Parcel::*write_func)(const T&));
411    template<typename T>
412    status_t            writeTypedVector(const std::vector<T>& val,
413                                         status_t(Parcel::*write_func)(T));
414
415    status_t            mError;
416    uint8_t*            mData;
417    size_t              mDataSize;
418    size_t              mDataCapacity;
419    mutable size_t      mDataPos;
420    binder_size_t*      mObjects;
421    size_t              mObjectsSize;
422    size_t              mObjectsCapacity;
423    mutable size_t      mNextObjectHint;
424
425    mutable bool        mFdsKnown;
426    mutable bool        mHasFds;
427    bool                mAllowFds;
428
429    release_func        mOwner;
430    void*               mOwnerCookie;
431
432    class Blob {
433    public:
434        Blob();
435        ~Blob();
436
437        void clear();
438        void release();
439        inline size_t size() const { return mSize; }
440        inline int fd() const { return mFd; };
441        inline bool isMutable() const { return mMutable; }
442
443    protected:
444        void init(int fd, void* data, size_t size, bool isMutable);
445
446        int mFd; // owned by parcel so not closed when released
447        void* mData;
448        size_t mSize;
449        bool mMutable;
450    };
451
452    class FlattenableHelperInterface {
453    protected:
454        ~FlattenableHelperInterface() { }
455    public:
456        virtual size_t getFlattenedSize() const = 0;
457        virtual size_t getFdCount() const = 0;
458        virtual status_t flatten(void* buffer, size_t size, int* fds, size_t count) const = 0;
459        virtual status_t unflatten(void const* buffer, size_t size, int const* fds, size_t count) = 0;
460    };
461
462    template<typename T>
463    class FlattenableHelper : public FlattenableHelperInterface {
464        friend class Parcel;
465        const Flattenable<T>& val;
466        explicit FlattenableHelper(const Flattenable<T>& val) : val(val) { }
467
468    public:
469        virtual size_t getFlattenedSize() const {
470            return val.getFlattenedSize();
471        }
472        virtual size_t getFdCount() const {
473            return val.getFdCount();
474        }
475        virtual status_t flatten(void* buffer, size_t size, int* fds, size_t count) const {
476            return val.flatten(buffer, size, fds, count);
477        }
478        virtual status_t unflatten(void const* buffer, size_t size, int const* fds, size_t count) {
479            return const_cast<Flattenable<T>&>(val).unflatten(buffer, size, fds, count);
480        }
481    };
482    status_t write(const FlattenableHelperInterface& val);
483    status_t read(FlattenableHelperInterface& val) const;
484
485public:
486    class ReadableBlob : public Blob {
487        friend class Parcel;
488    public:
489        inline const void* data() const { return mData; }
490        inline void* mutableData() { return isMutable() ? mData : NULL; }
491    };
492
493    class WritableBlob : public Blob {
494        friend class Parcel;
495    public:
496        inline void* data() { return mData; }
497    };
498
499private:
500    size_t mOpenAshmemSize;
501
502public:
503    // TODO: Remove once ABI can be changed.
504    size_t getBlobAshmemSize() const;
505    size_t getOpenAshmemSize() const;
506};
507
508// ---------------------------------------------------------------------------
509
510template<typename T>
511status_t Parcel::write(const Flattenable<T>& val) {
512    const FlattenableHelper<T> helper(val);
513    return write(helper);
514}
515
516template<typename T>
517status_t Parcel::write(const LightFlattenable<T>& val) {
518    size_t size(val.getFlattenedSize());
519    if (!val.isFixedSize()) {
520        status_t err = writeInt32(size);
521        if (err != NO_ERROR) {
522            return err;
523        }
524    }
525    if (size) {
526        void* buffer = writeInplace(size);
527        if (buffer == NULL)
528            return NO_MEMORY;
529        return val.flatten(buffer, size);
530    }
531    return NO_ERROR;
532}
533
534template<typename T>
535status_t Parcel::read(Flattenable<T>& val) const {
536    FlattenableHelper<T> helper(val);
537    return read(helper);
538}
539
540template<typename T>
541status_t Parcel::read(LightFlattenable<T>& val) const {
542    size_t size;
543    if (val.isFixedSize()) {
544        size = val.getFlattenedSize();
545    } else {
546        int32_t s;
547        status_t err = readInt32(&s);
548        if (err != NO_ERROR) {
549            return err;
550        }
551        size = s;
552    }
553    if (size) {
554        void const* buffer = readInplace(size);
555        return buffer == NULL ? NO_MEMORY :
556                val.unflatten(buffer, size);
557    }
558    return NO_ERROR;
559}
560
561template<typename T>
562status_t Parcel::readStrongBinder(sp<T>* val) const {
563    sp<IBinder> tmp;
564    status_t ret = readStrongBinder(&tmp);
565
566    if (ret == OK) {
567        *val = interface_cast<T>(tmp);
568
569        if (val->get() == nullptr) {
570            return UNKNOWN_ERROR;
571        }
572    }
573
574    return ret;
575}
576
577template<typename T, typename U>
578status_t Parcel::unsafeReadTypedVector(
579        std::vector<T>* val,
580        status_t(Parcel::*read_func)(U*) const) const {
581    int32_t size;
582    status_t status = this->readInt32(&size);
583
584    if (status != OK) {
585        return status;
586    }
587
588    if (size < 0) {
589        return UNEXPECTED_NULL;
590    }
591
592    val->resize(size);
593
594    for (auto& v: *val) {
595        status = (this->*read_func)(&v);
596
597        if (status != OK) {
598            return status;
599        }
600    }
601
602    return OK;
603}
604
605template<typename T>
606status_t Parcel::readTypedVector(std::vector<T>* val,
607                                 status_t(Parcel::*read_func)(T*) const) const {
608    return unsafeReadTypedVector(val, read_func);
609}
610
611template<typename T>
612status_t Parcel::readNullableTypedVector(std::unique_ptr<std::vector<T>>* val,
613                                         status_t(Parcel::*read_func)(T*) const) const {
614    const int32_t start = dataPosition();
615    int32_t size;
616    status_t status = readInt32(&size);
617    val->reset();
618
619    if (status != OK || size < 0) {
620        return status;
621    }
622
623    setDataPosition(start);
624    val->reset(new std::vector<T>());
625
626    status = unsafeReadTypedVector(val->get(), read_func);
627
628    if (status != OK) {
629        val->reset();
630    }
631
632    return status;
633}
634
635template<typename T, typename U>
636status_t Parcel::unsafeWriteTypedVector(const std::vector<T>& val,
637                                        status_t(Parcel::*write_func)(U)) {
638    if (val.size() > std::numeric_limits<int32_t>::max()) {
639        return BAD_VALUE;
640    }
641
642    status_t status = this->writeInt32(val.size());
643
644    if (status != OK) {
645        return status;
646    }
647
648    for (const auto& item : val) {
649        status = (this->*write_func)(item);
650
651        if (status != OK) {
652            return status;
653        }
654    }
655
656    return OK;
657}
658
659template<typename T>
660status_t Parcel::writeTypedVector(const std::vector<T>& val,
661                                  status_t(Parcel::*write_func)(const T&)) {
662    return unsafeWriteTypedVector(val, write_func);
663}
664
665template<typename T>
666status_t Parcel::writeTypedVector(const std::vector<T>& val,
667                                  status_t(Parcel::*write_func)(T)) {
668    return unsafeWriteTypedVector(val, write_func);
669}
670
671template<typename T>
672status_t Parcel::writeNullableTypedVector(const std::unique_ptr<std::vector<T>>& val,
673                                          status_t(Parcel::*write_func)(const T&)) {
674    if (val.get() == nullptr) {
675        return this->writeInt32(-1);
676    }
677
678    return unsafeWriteTypedVector(*val, write_func);
679}
680
681template<typename T>
682status_t Parcel::writeNullableTypedVector(const std::unique_ptr<std::vector<T>>& val,
683                                          status_t(Parcel::*write_func)(T)) {
684    if (val.get() == nullptr) {
685        return this->writeInt32(-1);
686    }
687
688    return unsafeWriteTypedVector(*val, write_func);
689}
690
691template<typename T>
692status_t Parcel::readParcelableVector(std::vector<T>* val) const {
693    return unsafeReadTypedVector<T, Parcelable>(val, &Parcel::readParcelable);
694}
695
696template<typename T>
697status_t Parcel::readParcelableVector(std::unique_ptr<std::vector<std::unique_ptr<T>>>* val) const {
698    const int32_t start = dataPosition();
699    int32_t size;
700    status_t status = readInt32(&size);
701    val->reset();
702
703    if (status != OK || size < 0) {
704        return status;
705    }
706
707    setDataPosition(start);
708    val->reset(new std::vector<std::unique_ptr<T>>());
709
710    status = unsafeReadTypedVector(val->get(), &Parcel::readParcelable<T>);
711
712    if (status != OK) {
713        val->reset();
714    }
715
716    return status;
717}
718
719template<typename T>
720status_t Parcel::readParcelable(std::unique_ptr<T>* parcelable) const {
721    const int32_t start = dataPosition();
722    int32_t present;
723    status_t status = readInt32(&present);
724    parcelable->reset();
725
726    if (status != OK || !present) {
727        return status;
728    }
729
730    setDataPosition(start);
731    parcelable->reset(new T());
732
733    status = readParcelable(parcelable->get());
734
735    if (status != OK) {
736        parcelable->reset();
737    }
738
739    return status;
740}
741
742template<typename T>
743status_t Parcel::writeNullableParcelable(const std::unique_ptr<T>& parcelable) {
744    return writeRawNullableParcelable(parcelable.get());
745}
746
747template<typename T>
748status_t Parcel::writeParcelableVector(const std::vector<T>& val) {
749    return unsafeWriteTypedVector<T,const Parcelable&>(val, &Parcel::writeParcelable);
750}
751
752template<typename T>
753status_t Parcel::writeParcelableVector(const std::unique_ptr<std::vector<std::unique_ptr<T>>>& val) {
754    if (val.get() == nullptr) {
755        return this->writeInt32(-1);
756    }
757
758    return unsafeWriteTypedVector(*val, &Parcel::writeParcelable);
759}
760
761// ---------------------------------------------------------------------------
762
763inline TextOutput& operator<<(TextOutput& to, const Parcel& parcel)
764{
765    parcel.print(to);
766    return to;
767}
768
769// ---------------------------------------------------------------------------
770
771// Generic acquire and release of objects.
772void acquire_object(const sp<ProcessState>& proc,
773                    const flat_binder_object& obj, const void* who);
774void release_object(const sp<ProcessState>& proc,
775                    const flat_binder_object& obj, const void* who);
776
777void flatten_binder(const sp<ProcessState>& proc,
778                    const sp<IBinder>& binder, flat_binder_object* out);
779void flatten_binder(const sp<ProcessState>& proc,
780                    const wp<IBinder>& binder, flat_binder_object* out);
781status_t unflatten_binder(const sp<ProcessState>& proc,
782                          const flat_binder_object& flat, sp<IBinder>* out);
783status_t unflatten_binder(const sp<ProcessState>& proc,
784                          const flat_binder_object& flat, wp<IBinder>* out);
785
786}; // namespace android
787
788// ---------------------------------------------------------------------------
789
790#endif // ANDROID_PARCEL_H
791