Parcel.h revision f26a3ab7758bdbc1c87940216e542b2cc58c4377
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