Android中的Parcel机制，面试必会

335. return NO_ERROR;

336. }

337. status_t Parcel::setData(const uint8_t* buffer, size_t len)

338. {

339. status_t err = restartWrite(len);

340. if (err == NO_ERROR) {

341. memcpy(const_cast<uint8_t*>(data()), buffer, len);

342. mDataSize = len;

343. mFdsKnown = false;

344. }

345. return err;

346. }

347. status_t Parcel::appendFrom(Parcel *parcel, size_t offset, size_t len)

348. {

349. const sp proc(ProcessState::self());

350. status_t err;

351. uint8_t *data = parcel->mData;

352. size_t *objects = parcel->mObjects;

353. size_t size = parcel->mObjectsSize;

354. int startPos = mDataPos;

355. int firstIndex = -1, lastIndex = -2;

356. if (len == 0) {

357. return NO_ERROR;

358. }

359. // range checks against the source parcel size

360. if ((offset > parcel->mDataSize)

361. || (len > parcel->mDataSize)

362. || (offset + len > parcel->mDataSize)) {

363. return BAD_VALUE;

364. }

365. // Count objects in range

366. for (int i = 0; i < (int) size; i++) {

367. size_t off = objects[i];

368. if ((off >= offset) && (off < offset + len)) {

369. if (firstIndex == -1) {

370. firstIndex = i;

371. }

372. lastIndex = i;

373. }

374. }

375. int numObjects = lastIndex - firstIndex + 1;

376. // grow data

377. err = growData(len);

378. if (err != NO_ERROR) {

379. return err;

380. }

381. // append data

382. memcpy(mData + mDataPos, data + offset, len);

383. mDataPos += len;

384. mDataSize += len;

385. if (numObjects > 0) {

386. // grow objects

387. if (mObjectsCapacity < mObjectsSize + numObjects) {

388. int newSize = ((mObjectsSize + numObjects)*3)/2;

389. size_t *objects =

390. (size_t*)realloc(mObjects, newSize*sizeof(size_t));

391. if (objects == (size_t*)0) {

392. return NO_MEMORY;

393. }

394. mObjects = objects;

395. mObjectsCapacity = newSize;

396. }

397. // append and acquire objects

398. int idx = mObjectsSize;

399. for (int i = firstIndex; i <= lastIndex; i++) {

400. size_t off = objects[i] - offset + startPos;

401. mObjects[idx++] = off;

402. mObjectsSize++;

403. flat_binder_object* flat

404. = reinterpret_cast<flat_binder_object*>(mData + off);

405. acquire_object(proc, *flat, this);

406. if (flat->type == BINDER_TYPE_FD) {

407. // If this is a file descriptor, we need to dup it so the

408. // new Parcel now owns its own fd, and can declare that we

409. // officially know we have fds.

410. flat->handle = dup(flat->handle);

411. flat->cookie = (void*)1;

412. mHasFds = mFdsKnown = true;

413. }

414. }

415. }

416. return NO_ERROR;

417. }

418. bool Parcel::hasFileDescriptors() const

419. {

420. if (!mFdsKnown) {

421. scanForFds();

422. }

423. return mHasFds;

424. }

425. status_t Parcel::writeInterfaceToken(const String16& interface)

426. {

427. // currently the interface identification token is just its name as a string

428. return writeString16(interface);

429. }

430. bool Parcel::checkInterface(IBinder* binder) const

431. {

432. return enforceInterface(binder->getInterfaceDescriptor());

433. }

434. bool Parcel::enforceInterface(const String16& interface) const

435. {

436. const String16 str(readString16());

437. if (str == interface) {

438. return true;

439. } else {

440. LOGW(“**** enforceInterface() expected ‘%s’ but read ‘%s’/n”,

441. String8(interface).string(), String8(str).string());

442. return false;

443. }

444. }

445. const size_t* Parcel::objects() const

446. {

447. return mObjects;

448. }

449. size_t Parcel::objectsCount() const

450. {

451. return mObjectsSize;

452. }

453. status_t Parcel::errorCheck() const

454. {

455. return mError;

456. }

457. void Parcel::setError(status_t err)

458. {

459. mError = err;

460. }

461. status_t Parcel::finishWrite(size_t len)

462. {

463. //printf(“Finish write of %d/n”, len);

464. mDataPos += len;

465. LOGV(“finishWrite Setting data pos of %p to %d/n”, this, mDataPos);

466. if (mDataPos > mDataSize) {

467. mDataSize = mDataPos;

468. LOGV(“finishWrite Setting data size of %p to %d/n”, this, mDataSize);

469. }

470. //printf(“New pos=%d, size=%d/n”, mDataPos, mDataSize);

471. return NO_ERROR;

472. }

473. status_t Parcel::writeUnpadded(const void* data, size_t len)

474. {

475. size_t end = mDataPos + len;

476. if (end < mDataPos) {

477. // integer overflow

478. return BAD_VALUE;

479. }

480. if (end <= mDataCapacity) {

481. restart_write:

482. memcpy(mData+mDataPos, data, len);

483. return finishWrite(len);

484. }

485. status_t err = growData(len);

486. if (err == NO_ERROR) goto restart_write;

487. return err;

488. }

489. status_t Parcel::write(const void* data, size_t len)

490. {

491. void* const d = writeInplace(len);

492. if (d) {

493. memcpy(d, data, len);

494. return NO_ERROR;

495. }

496. return mError;

497. }

498. void* Parcel::writeInplace(size_t len)

499. {

500. const size_t padded = PAD_SIZE(len);

501. // sanity check for integer overflow

502. if (mDataPos+padded < mDataPos) {

503. return NULL;

504. }

505. if ((mDataPos+padded) <= mDataCapacity) {

506. restart_write:

507. //printf(“Writing %ld bytes, padded to %ld/n”, len, padded);

508. uint8_t* const data = mData+mDataPos;

509. // Need to pad at end?

510. if (padded != len) {

511. #if BYTE_ORDER == BIG_ENDIAN

512. static const uint32_t mask[4] = {

513. 0x00000000, 0xffffff00, 0xffff0000, 0xff000000

514. };

515. #endif

516. #if BYTE_ORDER == LITTLE_ENDIAN

517. static const uint32_t mask[4] = {

518. 0x00000000, 0x00ffffff, 0x0000ffff, 0x000000ff

519. };

520. #endif

521. //printf(“Applying pad mask: %p to %p/n”, (void*)mask[padded-len],

522. //    *reinterpret_cast<void**>(data+padded-4));

523. *reinterpret_cast<uint32_t*>(data+padded-4) &= mask[padded-len];

524. }

525. finishWrite(padded);

526. return data;

527. }

528. status_t err = growData(padded);

529. if (err == NO_ERROR) goto restart_write;

530. return NULL;

531. }

532. status_t Parcel::writeInt32(int32_t val)

533. {

534. return writeAligned(val);

535. }

536. status_t Parcel::writeInt64(int64_t val)

537. {

538. return writeAligned(val);

539. }

540. status_t Parcel::writeFloat(float val)

541. {

542. return writeAligned(val);

543. }

544. status_t Parcel::writeDouble(double val)

545. {

546. return writeAligned(val);

547. }

548. status_t Parcel::writeIntPtr(intptr_t val)

549. {

550. return writeAligned(val);

551. }

552. status_t Parcel::writeCString(const char* str)

553. {

554. return write(str, strlen(str)+1);

555. }

556. status_t Parcel::writeString8(const String8& str)

557. {

558. status_t err = writeInt32(str.bytes());

559. if (err == NO_ERROR) {

560. err = write(str.string(), str.bytes()+1);

561. }

562. return err;

563. }

564. status_t Parcel::writeString16(const String16& str)

565. {

566. return writeString16(str.string(), str.size());

567. }

568. status_t Parcel::writeString16(const char16_t* str, size_t len)

569. {

570. if (str == NULL) return writeInt32(-1);

571. status_t err = writeInt32(len);

572. if (err == NO_ERROR) {

573. len *= sizeof(char16_t);

574. uint8_t* data = (uint8_t*)writeInplace(len+sizeof(char16_t));

575. if (data) {

576. memcpy(data, str, len);

577. *reinterpret_cast<char16_t*>(data+len) = 0;

578. return NO_ERROR;

579. }

580. err = mError;

581. }

582. return err;

583. }

584. status_t Parcel::writeStrongBinder(const sp& val)

585. {

586. return flatten_binder(ProcessState::self(), val, this);

587. }

588. status_t Parcel::writeWeakBinder(const wp& val)

589. {

590. return flatten_binder(ProcessState::self(), val, this);

591. }

592. status_t Parcel::writeNativeHandle(const native_handle* handle)

593. {

594. if (!handle || handle->version != sizeof(native_handle))

595. return BAD_TYPE;

596. status_t err;

597. err = writeInt32(handle->numFds);

598. if (err != NO_ERROR) return err;

599. err = writeInt32(handle->numInts);

600. if (err != NO_ERROR) return err;

601. for (int i=0 ; err==NO_ERROR && inumFds ; i++)

602. err = writeDupFileDescriptor(handle->data[i]);

603. if (err != NO_ERROR) {

604. LOGD(“write native handle, write dup fd failed”);

605. return err;

606. }

607. err = write(handle->data + handle->numFds, sizeof(int)*handle->numInts);

608. return err;

609. }

610. status_t Parcel::writeFileDescriptor(int fd)

611. {

612. flat_binder_object obj;

613. obj.type = BINDER_TYPE_FD;

614. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;

615. obj.handle = fd;

616. obj.cookie = (void*)0;

617. return writeObject(obj, true);

618. }

619. status_t Parcel::writeDupFileDescriptor(int fd)

620. {

621. flat_binder_object obj;

622. obj.type = BINDER_TYPE_FD;

623. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;

624. obj.handle = dup(fd);

625. obj.cookie = (void*)1;

626. return writeObject(obj, true);

627. }

628. status_t Parcel::write(const Flattenable& val)

629. {

630. status_t err;

631. // size if needed

632. size_t len = val.getFlattenedSize();

633. size_t fd_count = val.getFdCount();

634. err = this->writeInt32(len);

635. if (err) return err;

636. err = this->writeInt32(fd_count);

637. if (err) return err;

638. // payload

639. void* buf = this->writeInplace(PAD_SIZE(len));

640. if (buf == NULL)

641. return BAD_VALUE;

642. int* fds = NULL;

643. if (fd_count) {

644. fds = new int[fd_count];

645. }

646. err = val.flatten(buf, len, fds, fd_count);

647. for (size_t i=0 ; i<fd_count && err==NO_ERROR ; i++) {

648. err = this->writeDupFileDescriptor( fds[i] );

649. }

650. if (fd_count) {

651. delete [] fds;

652. }

653. return err;

654. }

655. status_t Parcel::writeObject(const flat_binder_object& val, bool nullMetaData)

656. {

657. const bool enoughData = (mDataPos+sizeof(val)) <= mDataCapacity;

658. const bool enoughObjects = mObjectsSize < mObjectsCapacity;

659. if (enoughData && enoughObjects) {

660. restart_write:

661. *reinterpret_cast<flat_binder_object*>(mData+mDataPos) = val;

662. // Need to write meta-data?

663. if (nullMetaData || val.binder != NULL) {

664. mObjects[mObjectsSize] = mDataPos;

665. acquire_object(ProcessState::self(), val, this);

666. mObjectsSize++;

667. }

668. // remember if it’s a file descriptor

669. if (val.type == BINDER_TYPE_FD) {

670. mHasFds = mFdsKnown = true;

671. }

672. return finishWrite(sizeof(flat_binder_object));

673. }

674. if (!enoughData) {

675. const status_t err = growData(sizeof(val));

676. if (err != NO_ERROR) return err;

677. }

678. if (!enoughObjects) {

679. size_t newSize = ((mObjectsSize+2)*3)/2;

680. size_t* objects = (size_t*)realloc(mObjects, newSize*sizeof(size_t));

681. if (objects == NULL) return NO_MEMORY;

682. mObjects = objects;

683. mObjectsCapacity = newSize;

684. }

685. goto restart_write;

686. }

687. void Parcel::remove(size_t start, size_t amt)

688. {

689. LOG_ALWAYS_FATAL(“Parcel::remove() not yet implemented!”);

690. }

691. status_t Parcel::read(void* outData, size_t len) const

692. {

693. if ((mDataPos+PAD_SIZE(len)) >= mDataPos && (mDataPos+PAD_SIZE(len)) <= mDataSize) {

694. memcpy(outData, mData+mDataPos, len);

695. mDataPos += PAD_SIZE(len);

696. LOGV(“read Setting data pos of %p to %d/n”, this, mDataPos);

697. return NO_ERROR;

698. }

699. return NOT_ENOUGH_DATA;

700. }

701. const void* Parcel::readInplace(size_t len) const

702. {

703. if ((mDataPos+PAD_SIZE(len)) >= mDataPos && (mDataPos+PAD_SIZE(len)) <= mDataSize) {

704. const void* data = mData+mDataPos;

705. mDataPos += PAD_SIZE(len);

706. LOGV(“readInplace Setting data pos of %p to %d/n”, this, mDataPos);

707. return data;

708. }

709. return NULL;

710. }

711. template

712. status_t Parcel::readAligned(T *pArg) const {

713. COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T)) == sizeof(T));

714. if ((mDataPos+sizeof(T)) <= mDataSize) {

715. const void* data = mData+mDataPos;

716. mDataPos += sizeof(T);

717. *pArg =  *reinterpret_cast<const T*>(data);

718. return NO_ERROR;

719. } else {

720. return NOT_ENOUGH_DATA;

721. }

722. }

723. template

724. T Parcel::readAligned() const {

725. T result;

726. if (readAligned(&result) != NO_ERROR) {

727. result = 0;

728. }

729. return result;

730. }

731. template

732. status_t Parcel::writeAligned(T val) {

733. COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T)) == sizeof(T));

734. if ((mDataPos+sizeof(val)) <= mDataCapacity) {

735. restart_write:

736. *reinterpret_cast<T*>(mData+mDataPos) = val;

737. return finishWrite(sizeof(val));

738. }

739. status_t err = growData(sizeof(val));

740. if (err == NO_ERROR) goto restart_write;

741. return err;

742. }

743. status_t Parcel::readInt32(int32_t *pArg) const

744. {

745. return readAligned(pArg);

746. }

747. int32_t Parcel::readInt32() const

748. {

749. return readAligned<int32_t>();

750. }

751. status_t Parcel::readInt64(int64_t *pArg) const

752. {

753. return readAligned(pArg);

754. }

755. int64_t Parcel::readInt64() const

756. {

757. return readAligned<int64_t>();

758. }

759. status_t Parcel::readFloat(float *pArg) const

760. {

761. return readAligned(pArg);

762. }

763. float Parcel::readFloat() const

764. {

765. return readAligned<float>();

766. }

767. status_t Parcel::readDouble(double *pArg) const

768. {

769. return readAligned(pArg);

770. }

771. double Parcel::readDouble() const

772. {

773. return readAligned<double>();

774. }

775. status_t Parcel::readIntPtr(intptr_t *pArg) const

776. {

777. return readAligned(pArg);

778. }

779. intptr_t Parcel::readIntPtr() const

780. {

781. return readAligned<intptr_t>();

782. }

783. const char* Parcel::readCString() const

784. {

785. const size_t avail = mDataSize-mDataPos;

786. if (avail > 0) {

787. const char* str = reinterpret_cast<const char*>(mData+mDataPos);

788. // is the string’s trailing NUL within the parcel’s valid bounds?

789. const char* eos = reinterpret_cast<const char*>(memchr(str, 0, avail));

790. if (eos) {

791. const size_t len = eos - str;

792. mDataPos += PAD_SIZE(len+1);

793. LOGV(“readCString Setting data pos of %p to %d/n”, this, mDataPos);

794. return str;

795. }

796. }

797. return NULL;

798. }

799. String8 Parcel::readString8() const

800. {

801. int32_t size = readInt32();

802. // watch for potential int overflow adding 1 for trailing NUL

803. if (size > 0 && size < INT32_MAX) {

804. const char* str = (const char*)readInplace(size+1);

805. if (str) return String8(str, size);

806. }

807. return String8();

808. }

809. String16 Parcel::readString16() const

810. {

811. size_t len;

812. const char16_t* str = readString16Inplace(&len);

813. if (str) return String16(str, len);

814. LOGE(“Reading a NULL string not supported here.”);

815. return String16();

816. }

817. const char16_t* Parcel::readString16Inplace(size_t* outLen) const

818. {

819. int32_t size = readInt32();

820. // watch for potential int overflow from size+1

821. if (size >= 0 && size < INT32_MAX) {

822. *outLen = size;

823. const char16_t* str = (const char16_t*)readInplace((size+1)*sizeof(char16_t));

824. if (str != NULL) {

825. return str;

826. }

827. }

828. *outLen = 0;

829. return NULL;

830. }

831. sp Parcel::readStrongBinder() const

832. {

833. sp val;

834. unflatten_binder(ProcessState::self(), *this, &val);

835. return val;

836. }

837. wp Parcel::readWeakBinder() const

838. {

839. wp val;

840. unflatten_binder(ProcessState::self(), *this, &val);

841. return val;

842. }

843. native_handle* Parcel::readNativeHandle() const

844. {

845. int numFds, numInts;

846. status_t err;

847. err = readInt32(&numFds);

848. if (err != NO_ERROR) return 0;

849. err = readInt32(&numInts);

850. if (err != NO_ERROR) return 0;

851. native_handle* h = native_handle_create(numFds, numInts);

852. for (int i=0 ; err==NO_ERROR && i<numFds ; i++) {

853. h->data[i] = dup(readFileDescriptor());

854. if (h->data[i] < 0) err = BAD_VALUE;

855. }

856. err = read(h->data + numFds, sizeof(int)*numInts);

857. if (err != NO_ERROR) {

858. native_handle_close(h);

859. native_handle_delete(h);

860. h = 0;

861. }

862. return h;

863. }

864. int Parcel::readFileDescriptor() const

865. {

866. const flat_binder_object* flat = readObject(true);

867. if (flat) {

868. switch (flat->type) {

869. case BINDER_TYPE_FD:

870. //LOGI(“Returning file descriptor %ld from parcel %p/n”, flat->handle, this);

871. return flat->handle;

872. }

873. }

874. return BAD_TYPE;

875. }

876. status_t Parcel::read(Flattenable& val) const

877. {

878. // size

879. const size_t len = this->readInt32();

880. const size_t fd_count = this->readInt32();

881. // payload

882. void const* buf = this->readInplace(PAD_SIZE(len));

883. if (buf == NULL)

884. return BAD_VALUE;

885. int* fds = NULL;

886. if (fd_count) {

887. fds = new int[fd_count];

888. }

889. status_t err = NO_ERROR;

890. for (size_t i=0 ; i<fd_count && err==NO_ERROR ; i++) {

891. fds[i] = dup(this->readFileDescriptor());

892. if (fds[i] < 0) err = BAD_VALUE;

893. }

894. if (err == NO_ERROR) {

895. err = val.unflatten(buf, len, fds, fd_count);

896. }

897. if (fd_count) {

898. delete [] fds;

899. }

900. return err;

901. }

902. const flat_binder_object* Parcel::readObject(bool nullMetaData) const

903. {

904. const size_t DPOS = mDataPos;

905. if ((DPOS+sizeof(flat_binder_object)) <= mDataSize) {

906. const flat_binder_object* obj

907. = reinterpret_cast<const flat_binder_object*>(mData+DPOS);

908. mDataPos = DPOS + sizeof(flat_binder_object);

909. if (!nullMetaData && (obj->cookie == NULL && obj->binder == NULL)) {

910. // When transferring a NULL object, we don’t write it into

911. // the object list, so we don’t want to check for it when

912. // reading.

913. LOGV(“readObject Setting data pos of %p to %d/n”, this, mDataPos);

914. return obj;

915. }

916. // Ensure that this object is valid…

917. size_t* const OBJS = mObjects;

918. const size_t N = mObjectsSize;

919. size_t opos = mNextObjectHint;

920. if (N > 0) {

921. LOGV(“Parcel %p looking for obj at %d, hint=%d/n”,

922. this, DPOS, opos);

923. // Start at the current hint position, looking for an object at

924. // the current data position.

925. if (opos < N) {

926. while (opos < (N-1) && OBJS[opos] < DPOS) {

927. opos++;

928. }

929. } else {

930. opos = N-1;

931. }

932. if (OBJS[opos] == DPOS) {

933. // Found it!

934. LOGV(“Parcel found obj %d at index %d with forward search”,

935. this, DPOS, opos);

936. mNextObjectHint = opos+1;

937. LOGV(“readObject Setting data pos of %p to %d/n”, this, mDataPos);

938. return obj;

939. }

940. // Look backwards for it…

941. while (opos > 0 && OBJS[opos] > DPOS) {

942. opos–;

943. }

944. if (OBJS[opos] == DPOS) {

945. // Found it!

946. LOGV(“Parcel found obj %d at index %d with backward search”,

947. this, DPOS, opos);

948. mNextObjectHint = opos+1;

949. LOGV(“readObject Setting data pos of %p to %d/n”, this, mDataPos);

950. return obj;

951. }

952. }

953. LOGW(“Attempt to read object from Parcel %p at offset %d that is not in the object list”,

954. this, DPOS);

955. }

956. return NULL;

957. }

958. void Parcel::closeFileDescriptors()

959. {

960. size_t i = mObjectsSize;

961. if (i > 0) {

962. //LOGI(“Closing file descriptors for %d objects…”, mObjectsSize);

963. }

964. while (i > 0) {

965. i–;

966. const flat_binder_object* flat

967. = reinterpret_cast<flat_binder_object*>(mData+mObjects[i]);

968. if (flat->type == BINDER_TYPE_FD) {

969. //LOGI(“Closing fd: %ld/n”, flat->handle);

970. close(flat->handle);

971. }

972. }

973. }

974. const uint8_t* Parcel::ipcData() const

975. {

976. return mData;

977. }

978. size_t Parcel::ipcDataSize() const

979. {

980. return (mDataSize > mDataPos ? mDataSize : mDataPos);

981. }

982. const size_t* Parcel::ipcObjects() const

983. {

984. return mObjects;

985. }

986. size_t Parcel::ipcObjectsCount() const

987. {

988. return mObjectsSize;

989. }

990. void Parcel::ipcSetDataReference(const uint8_t* data, size_t dataSize,

991. const size_t* objects, size_t objectsCount, release_func relFunc, void* relCookie)

992. {

993. freeDataNoInit();

994. mError = NO_ERROR;

995. mData = const_cast<uint8_t*>(data);

996. mDataSize = mDataCapacity = dataSize;

997. //LOGI(“setDataReference Setting data size of %p to %lu (pid=%d)/n”, this, mDataSize, getpid());

998. mDataPos = 0;

999. LOGV(“setDataReference Setting data pos of %p to %d/n”, this, mDataPos);

1000. mObjects = const_cast<size_t*>(objects);

1001. mObjectsSize = mObjectsCapacity = objectsCount;

1002. mNextObjectHint = 0;

1003. mOwner = relFunc;

1004. mOwnerCookie = relCookie;

1005. scanForFds();

1006. }

1007. void Parcel::print(TextOutput& to, uint32_t flags) const

1008. {

1009. to << “Parcel(”;

1010. if (errorCheck() != NO_ERROR) {

1011. const status_t err = errorCheck();

1012. to << “Error: " << (void*)err << " /”" << strerror(-err) << “/”";

1013. } else if (dataSize() > 0) {

1014. const uint8_t* DATA = data();

1015. to << indent << HexDump(DATA, dataSize()) << dedent;

1016. const size_t* OBJS = objects();

1017. const size_t N = objectsCount();

1018. for (size_t i=0; i<N; i++) {

1019. const flat_binder_object* flat

1020. = reinterpret_cast<const flat_binder_object*>(DATA+OBJS[i]);

1021. to << endl << “Object #” << i << " @ " << (void*)OBJS[i] << ": "

1022. << TypeCode(flat->type & 0x7f7f7f00)

1023. << " = " << flat->binder;

1024. }

1025. } else {

1026. to << “NULL”;

1027. }

1028. to << “)”;

1029. }

1030. void Parcel::releaseObjects()

1031. {

1032. const sp proc(ProcessState::self());

1033. size_t i = mObjectsSize;

1034. uint8_t* const data = mData;

1035. size_t* const objects = mObjects;

1036. while (i > 0) {

1037. i–;

1038. const flat_binder_object* flat

1039. = reinterpret_cast<flat_binder_object*>(data+objects[i]);

1040. release_object(proc, *flat, this);

1041. }

1042. }

1043. void Parcel::acquireObjects()

1044. {

1045. const sp proc(ProcessState::self());

1046. size_t i = mObjectsSize;

1047. uint8_t* const data = mData;

1048. size_t* const objects = mObjects;

1049. while (i > 0) {

1050. i–;

1051. const flat_binder_object* flat

1052. = reinterpret_cast<flat_binder_object*>(data+objects[i]);

1053. acquire_object(proc, *flat, this);

1054. }

1055. }

1056. void Parcel::freeData()

1057. {

1058. freeDataNoInit();

1059. initState();

1060. }

1061. void Parcel::freeDataNoInit()

1062. {

1063. if (mOwner) {

1064. //LOGI(“Freeing data ref of %p (pid=%d)/n”, this, getpid());

1065. mOwner(this, mData, mDataSize, mObjects, mObjectsSize, mOwnerCookie);

1066. } else {

1067. releaseObjects();

1068. if (mData) free(mData);

1069. if (mObjects) free(mObjects);

1070. }

1071. }

1072. status_t Parcel::growData(size_t len)

1073. {

1074. size_t newSize = ((mDataSize+len)*3)/2;

1075. return (newSize <= mDataSize)

1076. ? (status_t) NO_MEMORY

1077. : continueWrite(newSize);

1078. }

1079. status_t Parcel::restartWrite(size_t desired)

1080. {

1081. if (mOwner) {

1082. freeData();

1083. return continueWrite(desired);

1084. }

1085. uint8_t* data = (uint8_t*)realloc(mData, desired);

1086. if (!data && desired > mDataCapacity) {

1087. mError = NO_MEMORY;

1088. return NO_MEMORY;

1089. }

1090. releaseObjects();

1091. if (data) {

1092. mData = data;

1093. mDataCapacity = desired;

1094. }

1095. mDataSize = mDataPos = 0;

1096. LOGV(“restartWrite Setting data size of %p to %d/n”, this, mDataSize);

1097. LOGV(“restartWrite Setting data pos of %p to %d/n”, this, mDataPos);

1098. free(mObjects);

1099. mObjects = NULL;

1100. mObjectsSize = mObjectsCapacity = 0;

1101. mNextObjectHint = 0;

1102. mHasFds = false;

1103. mFdsKnown = true;

1104. return NO_ERROR;

1105. }

1106. status_t Parcel::continueWrite(size_t desired)

1107. {

1108. // If shrinking, first adjust for any objects that appear

1109. // after the new data size.

1110. size_t objectsSize = mObjectsSize;

1111. if (desired < mDataSize) {

1112. if (desired == 0) {

1113. objectsSize = 0;

1114. } else {

1115. while (objectsSize > 0) {

1116. if (mObjects[objectsSize-1] < desired)

1117. break;

1118. objectsSize–;

1119. }

1120. }

1121. }

1122. if (mOwner) {

1123. // If the size is going to zero, just release the owner’s data.

1124. if (desired == 0) {

1125. freeData();

1126. return NO_ERROR;

1127. }

1128. // If there is a different owner, we need to take

1129. // posession.

1130. uint8_t* data = (uint8_t*)malloc(desired);

1131. if (!data) {

1132. mError = NO_MEMORY;

1133. return NO_MEMORY;

1134. }

1135. size_t* objects = NULL;

1136. if (objectsSize) {

1137. objects = (size_t*)malloc(objectsSize*sizeof(size_t));

1138. if (!objects) {

1139. mError = NO_MEMORY;

1140. return NO_MEMORY;

1141. }

1142. // Little hack to only acquire references on objects

1143. // we will be keeping.

1144. size_t oldObjectsSize = mObjectsSize;

1145. mObjectsSize = objectsSize;

1146. acquireObjects();

1147. mObjectsSize = oldObjectsSize;

1148. }

1149. if (mData) {

1150. memcpy(data, mData, mDataSize < desired ? mDataSize : desired);

1151. }

1152. if (objects && mObjects) {

1153. memcpy(objects, mObjects, objectsSize*sizeof(size_t));

1154. }

1155. //LOGI(“Freeing data ref of %p (pid=%d)/n”, this, getpid());

1156. mOwner(this, mData, mDataSize, mObjects, mObjectsSize, mOwnerCookie);

1157. mOwner = NULL;

1158. mData = data;

1159. mObjects = objects;

1160. mDataSize = (mDataSize < desired) ? mDataSize : desired;

1161. LOGV(“continueWrite Setting data size of %p to %d/n”, this, mDataSize);

1162. mDataCapacity = desired;

1163. mObjectsSize = mObjectsCapacity = objectsSize;

1164. mNextObjectHint = 0;

1165. } else if (mData) {

1166. if (objectsSize < mObjectsSize) {

1167. // Need to release refs on any objects we are dropping.

1168. const sp proc(ProcessState::self());

1169. for (size_t i=objectsSize; i<mObjectsSize; i++) {

1170. const flat_binder_object* flat

1171. = reinterpret_cast<flat_binder_object*>(mData+mObjects[i]);

1172. if (flat->type == BINDER_TYPE_FD) {

1173. // will need to rescan because we may have lopped off the only FDs

1174. mFdsKnown = false;

1175. }

1176. release_object(proc, *flat, this);

1177. }

1178. size_t* objects =

1179. (size_t*)realloc(mObjects, objectsSize*sizeof(size_t));

1180. if (objects) {

1181. mObjects = objects;

1182. }

1183. mObjectsSize = objectsSize;

1184. mNextObjectHint = 0;

1185. }

1186. // We own the data, so we can just do a realloc().

1187. if (desired > mDataCapacity) {

1188. uint8_t* data = (uint8_t*)realloc(mData, desired);

1189. if (data) {

1190. mData = data;

1191. mDataCapacity = desired;

1192. } else if (desired > mDataCapacity) {

1193. mError = NO_MEMORY;

1194. return NO_MEMORY;

1195. }

1196. } else {

1197. mDataSize = desired;

1198. LOGV(“continueWrite Setting data size of %p to %d/n”, this, mDataSize);

1199. if (mDataPos > desired) {

1200. mDataPos = desired;

1201. LOGV(“continueWrite Setting data pos of %p to %d/n”, this, mDataPos);

1202. }

1203. }

1204. } else {

1205. // This is the first data.  Easy!

1206. uint8_t* data = (uint8_t*)malloc(desired);

1207. if (!data) {

1208. mError = NO_MEMORY;

1209. return NO_MEMORY;

1210. }

1211. if(!(mDataCapacity == 0 && mObjects == NULL

1212. && mObjectsCapacity == 0)) {

1213. LOGE(“continueWrite: %d/%p/%d/%d”, mDataCapacity, mObjects, mObjectsCapacity, desired);

1214. }

1215. mData = data;

1216. mDataSize = mDataPos = 0;

1217. LOGV(“continueWrite Setting data size of %p to %d/n”, this, mDataSize);

1218. LOGV(“continueWrite Setting data pos of %p to %d/n”, this, mDataPos);

1219. mDataCapacity = desired;

1220. }

1221. return NO_ERROR;

1222. }

1223. void Parcel::initState()

1224. {

1225. mError = NO_ERROR;

1226. mData = 0;

1227. mDataSize = 0;

1228. mDataCapacity = 0;

1229. mDataPos = 0;

1230. LOGV(“initState Setting data size of %p to %d/n”, this, mDataSize);

1231. LOGV(“initState Setting data pos of %p to %d/n”, this, mDataPos);

1232. mObjects = NULL;

1233. mObjectsSize = 0;

1234. mObjectsCapacity = 0;

1235. mNextObjectHint = 0;

1236. mHasFds = false;

1237. mFdsKnown = true;

1238. mOwner = NULL;

1239. }

1240. void Parcel::scanForFds() const

1241. {

1242. bool hasFds = false;

1243. for (size_t i=0; i<mObjectsSize; i++) {

1244. const flat_binder_object* flat

1245. = reinterpret_cast<const flat_binder_object*>(mData + mObjects[i]);

1246. if (flat->type == BINDER_TYPE_FD) {

1247. hasFds = true;

1248. break;

1249. }

1250. }

1251. mHasFds = hasFds;

1252. mFdsKnown = true;

1253. }

1254. }; // namespace android

本文的源码使用的是Android 2.1版本。

上一篇中我们透过源码看到了Parcel背后的机制，本质上把它当成一个Serialize就可以了，只是它是在内存中完成的序列化和反序列化，利用的是连续的内存空间，因此会更加高效。

我们接下来要说的是Parcel类如何应用。就应用程序而言，最常见使用Parcel类的场景就是在Activity间传递数据。没错，在Activity间使用Intent传递数据的时候，可以通过Parcelable机制传递复杂的对象。

在下面的程序中，MyColor用于保存一个颜色值，MainActivity在用户点击屏幕时将MyColor对象设成红色，传递到SubActivity中，此时SubActivity的TextView显示为红色的背景；当点击SubActivity时，将颜色值改为绿色，返回MainActivity，期望的是MainActivity的TextView显示绿色背景。

来看一下MyColor类的实现代码：

[java]  view plain copy

1. package com.wenbin.test;

2. import android.graphics.Color;

3. import android.os.Parcel;

4. import android.os.Parcelable;

5. /**

6. * @author 曹文斌

7. * http://blog.csdn.net/caowenbin

8. *

9. */

10. public class MyColor implements Parcelable {

11. private int color=Color.BLACK;

12. MyColor(){

13. color=Color.BLACK;

14. }

15. MyColor(Parcel in){

16. color=in.readInt();

17. }

18. public int getColor(){

19. return color;

20. }

21. public void setColor(int color){

22. this.color=color;

23. }

24. @Override

25. public int describeContents() {

26. return 0;

27. }

28. @Override

29. public void writeToParcel(Parcel dest, int flags) {

30. dest.writeInt(color);

31. }

32. public static final Parcelable.Creator CREATOR

33. = new Parcelable.Creator() {

34. public MyColor createFromParcel(Parcel in) {

35. return new MyColor(in);

36. }

37. public MyColor[] newArray(int size) {

38. return new MyColor[size];

39. }

40. };

41. }

该类实现了Parcelable接口，提供了默认的构造函数，同时也提供了可从Parcel对象开始的构造函数，另外还实现了一个static的构造器用于构造对象和数组。代码很简单，不一一解释了。

再看MainActivity的代码：

[java]  view plain copy

1. package com.wenbin.test;

2. import android.app.Activity;

3. import android.content.Intent;

4. import android.graphics.Color;

5. import android.os.Bundle;

6. import android.view.MotionEvent;

7. /**

8. * @author 曹文斌

9. * http://blog.csdn.net/caowenbin

10. *

11. */

12. public class MainActivity extends Activity {

13. private final int SUB_ACTIVITY=0;

14. private MyColor color=new MyColor();

15. @Override

16. public void onCreate(Bundle savedInstanceState) {

17. super.onCreate(savedInstanceState);

18. setContentView(R.layout.main);

19. }

20. @Override

21. protected void onActivityResult(int requestCode, int resultCode, Intent data) {

22. super.onActivityResult(requestCode, resultCode, data);

23. if (requestCode==SUB_ACTIVITY){

24. if (resultCode==RESULT_OK){

25. if (data.hasExtra(“MyColor”)){

26. color=data.getParcelableExtra(“MyColor”);  //Notice

27. findViewById(R.id.text).setBackgroundColor(color.getColor());

28. }

29. }

30. }

31. }

32. @Override

33. public boolean onTouchEvent(MotionEvent event){

34. if (event.getAction()==MotionEvent.ACTION_UP){

35. Intent intent=new Intent();

36. intent.setClass(this, SubActivity.class);

37. color.setColor(Color.RED);

38. intent.putExtra(“MyColor”, color);

39. startActivityForResult(intent,SUB_ACTIVITY);

40. }

41. return super.onTouchEvent(event);

42. }

43. }

下面是SubActivity的代码：

[java]  view plain copy

1. package com.wenbin.test;

2. import android.app.Activity;

3. import android.content.Intent;

4. import android.graphics.Color;

5. import android.os.Bundle;

6. import android.view.MotionEvent;

7. import android.widget.TextView;

8. /**

9. * @author 曹文斌

10. * http://blog.csdn.net/caowenbin

11. *

12. */

13. public class SubActivity extends Activity {

14. private MyColor color;

15. @Override

16. public void onCreate(Bundle savedInstanceState) {

17. super.onCreate(savedInstanceState);

18. setContentView(R.layout.main);

19. ((TextView)findViewById(R.id.text)).setText(“SubActivity”);

20. Intent intent=getIntent();

21. if (intent!=null){

22. if (intent.hasExtra(“MyColor”)){

23. color=intent.getParcelableExtra(“MyColor”);

24. findViewById(R.id.text).setBackgroundColor(color.getColor());

25. }

26. }

27. }

28. @Override

29. public boolean onTouchEvent(MotionEvent event){

30. if (event.getAction()==MotionEvent.ACTION_UP){

31. Intent intent=new Intent();

32. if (color!=null){

33. color.setColor(Color.GREEN);

34. intent.putExtra(“MyColor”, color);

35. }

36. setResult(RESULT_OK,intent);

37. finish();

38. }

39. return super.onTouchEvent(event);

40. }

41. }

下面是main.xml的代码：

[xhtml]  view plain copy

1. <?xml version\="1.0" encoding\="utf-8"?>  

2. <LinearLayout xmlns:android=“http://schemas.android.com/apk/res/android”

3. android:orientation=“vertical”

4. android:layout_width=“fill_parent”

5. android:layout_height=“fill_parent”

6. >

7. <TextView

8. android:layout_width=“fill_parent”

9. android:layout_height=“wrap_content”

10. android:text=“@string/hello”

11. android:id=“@+id/text”

12. />

13. </LinearLayout>

注意的是在MainActivity的onActivityResult()中，有一句color=data.getParcelableExtra(“MyColor”)，这说明的是反序列化后是一个新的MyColor对象，因此要想使用这个对象，我们做了这个赋值语句。

记得在上一篇《探索Android中的Parcel机制（上）》中提到，如果数据本身是IBinder类型，那么反序列化的结果就是原对象，而不是新建的对象，很显然，如果是这样的话，在反序列化后在MainActivity中就不再需要color=data.getParcelableExtra(“MyColor”)这句了。因此，换一种MyColor的实现方法，令其中的int color成员变量使用IBinder类型的成员变量来表示。

新建一个BinderData类继承自Binder，代码如下：

[java]  view plain copy

1. package com.wenbin.test;

2. import android.os.Binder;

3. /**

4. * @author 曹文斌

5. * http://blog.csdn.net/caowenbin

6. *

7. */

8. public class BinderData extends Binder {

9. public int color;

10. }

修改MyColor的代码如下：

[java]  view plain copy

1. package com.wenbin.test;

2. import android.graphics.Color;

3. import android.os.Parcel;

4. import android.os.Parcelable;

5. /**

6. * @author 曹文斌

7. * http://blog.csdn.net/caowenbin

8. *

9. */

10. public class MyColor implements Parcelable {

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

作者2013年从java开发，转做Android开发，在小厂待过，也去过华为，OPPO等大厂待过，18年四月份进了阿里一直到现在。

参与过不少面试，也当面试官 面试过很多人。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长，而且极易碰到天花板技术停滞不前！

我整理了一份阿里P7级别的最系统的Android开发主流技术，特别适合有3-5年以上经验的小伙伴深入学习提升。

主要包括阿里，以及字节跳动，腾讯，华为，小米，等一线互联网公司主流架构技术。如果你想深入系统学习Android开发，成为一名合格的高级工程师，可以收藏一下这些Android进阶技术选型

我搜集整理过这几年阿里，以及腾讯，字节跳动，华为，小米等公司的面试题，把面试的要求和技术点梳理成一份大而全的“ Android架构师”面试 Xmind（实际上比预期多花了不少精力），包含知识脉络 + 分支细节。

Java语言与原理；
大厂，小厂。Android面试先看你熟不熟悉Java语言

高级UI与自定义view；
自定义view，Android开发的基本功。

性能调优；
数据结构算法，设计模式。都是这里面的关键基础和重点需要熟练的。

NDK开发；
未来的方向，高薪必会。

前沿技术；
组件化，热升级，热修复，框架设计

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

我在搭建这些技术框架的时候，还整理了系统的高级进阶教程，会比自己碎片化学习效果强太多，CodeChina上可见；

当然，想要深入学习并掌握这些能力，并不简单。关于如何学习，做程序员这一行什么工作强度大家都懂，但是不管工作多忙，每周也要雷打不动的抽出 2 小时用来学习。

不出半年，你就能看出变化！

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

import android.os.Binder;

5. /**

6. * @author 曹文斌

7. * http://blog.csdn.net/caowenbin

8. *

9. */

10. public class BinderData extends Binder {

11. public int color;

12. }

修改MyColor的代码如下：

[java]  view plain copy

1. package com.wenbin.test;

2. import android.graphics.Color;

3. import android.os.Parcel;

4. import android.os.Parcelable;

5. /**

6. * @author 曹文斌

7. * http://blog.csdn.net/caowenbin

8. *

9. */

10. public class MyColor implements Parcelable {

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-oNxddtHS-1712376788619)]

[外链图片转存中…(img-N843CVe3-1712376788620)]

[外链图片转存中…(img-2c8F89ib-1712376788620)]

[外链图片转存中…(img-lhhoSEoO-1712376788620)]

[外链图片转存中…(img-oW19rWXz-1712376788621)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

作者2013年从java开发，转做Android开发，在小厂待过，也去过华为，OPPO等大厂待过，18年四月份进了阿里一直到现在。

参与过不少面试，也当面试官 面试过很多人。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长，而且极易碰到天花板技术停滞不前！

我整理了一份阿里P7级别的最系统的Android开发主流技术，特别适合有3-5年以上经验的小伙伴深入学习提升。

主要包括阿里，以及字节跳动，腾讯，华为，小米，等一线互联网公司主流架构技术。如果你想深入系统学习Android开发，成为一名合格的高级工程师，可以收藏一下这些Android进阶技术选型

我搜集整理过这几年阿里，以及腾讯，字节跳动，华为，小米等公司的面试题，把面试的要求和技术点梳理成一份大而全的“ Android架构师”面试 Xmind（实际上比预期多花了不少精力），包含知识脉络 + 分支细节。

[外链图片转存中…(img-lpwroPaq-1712376788621)]

Java语言与原理；
大厂，小厂。Android面试先看你熟不熟悉Java语言

[外链图片转存中…(img-uqyWAF9F-1712376788621)]

高级UI与自定义view；
自定义view，Android开发的基本功。

[外链图片转存中…(img-G5losp35-1712376788622)]

性能调优；
数据结构算法，设计模式。都是这里面的关键基础和重点需要熟练的。

[外链图片转存中…(img-IH7g0sEP-1712376788622)]

NDK开发；
未来的方向，高薪必会。

[外链图片转存中…(img-AWcjwxcg-1712376788622)]

前沿技术；
组件化，热升级，热修复，框架设计

[外链图片转存中…(img-VwXIL2Nx-1712376788622)]

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

我在搭建这些技术框架的时候，还整理了系统的高级进阶教程，会比自己碎片化学习效果强太多，CodeChina上可见；

当然，想要深入学习并掌握这些能力，并不简单。关于如何学习，做程序员这一行什么工作强度大家都懂，但是不管工作多忙，每周也要雷打不动的抽出 2 小时用来学习。

不出半年，你就能看出变化！

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！