Android中的Parcel机制，今年最新整理的《高频Android面试题集合》

116. }

117. return;

118. }

119. case BINDER_TYPE_WEAK_HANDLE: {

120. const wp b = proc->getWeakProxyForHandle(obj.handle);

121. if (b != NULL) b.get_refs()->decWeak(who);

122. return;

123. }

124. case BINDER_TYPE_FD: {

125. if (obj.cookie != (void*)0) close(obj.handle);

126. return;

127. }

128. }

129. LOGE(“Invalid object type 0x%08lx”, obj.type);

130. }

131. inline static status_t finish_flatten_binder(

132. const sp& binder, const flat_binder_object& flat, Parcel* out)

133. {

134. return out->writeObject(flat, false);

135. }

136. status_t flatten_binder(const sp& proc,

137. const sp& binder, Parcel* out)

138. {

139. flat_binder_object obj;

140. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;

141. if (binder != NULL) {

142. IBinder *local = binder->localBinder();

143. if (!local) {

144. BpBinder *proxy = binder->remoteBinder();

145. if (proxy == NULL) {

146. LOGE(“null proxy”);

147. }

148. const int32_t handle = proxy ? proxy->handle() : 0;

149. obj.type = BINDER_TYPE_HANDLE;

150. obj.handle = handle;

151. obj.cookie = NULL;

152. } else {

153. obj.type = BINDER_TYPE_BINDER;

154. obj.binder = local->getWeakRefs();

155. obj.cookie = local;

156. }

157. } else {

158. obj.type = BINDER_TYPE_BINDER;

159. obj.binder = NULL;

160. obj.cookie = NULL;

161. }

162. return finish_flatten_binder(binder, obj, out);

163. }

164. status_t flatten_binder(const sp& proc,

165. const wp& binder, Parcel* out)

166. {

167. flat_binder_object obj;

168. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;

169. if (binder != NULL) {

170. sp real = binder.promote();

171. if (real != NULL) {

172. IBinder *local = real->localBinder();

173. if (!local) {

174. BpBinder *proxy = real->remoteBinder();

175. if (proxy == NULL) {

176. LOGE(“null proxy”);

177. }

178. const int32_t handle = proxy ? proxy->handle() : 0;

179. obj.type = BINDER_TYPE_WEAK_HANDLE;

180. obj.handle = handle;

181. obj.cookie = NULL;

182. } else {

183. obj.type = BINDER_TYPE_WEAK_BINDER;

184. obj.binder = binder.get_refs();

185. obj.cookie = binder.unsafe_get();

186. }

187. return finish_flatten_binder(real, obj, out);

188. }

189. // XXX How to deal?  In order to flatten the given binder,

190. // we need to probe it for information, which requires a primary

191. // reference…  but we don’t have one.

192. //

193. // The OpenBinder implementation uses a dynamic_cast<> here,

194. // but we can’t do that with the different reference counting

195. // implementation we are using.

196. LOGE(“Unable to unflatten Binder weak reference!”);

197. obj.type = BINDER_TYPE_BINDER;

198. obj.binder = NULL;

199. obj.cookie = NULL;

200. return finish_flatten_binder(NULL, obj, out);

201. } else {

202. obj.type = BINDER_TYPE_BINDER;

203. obj.binder = NULL;

204. obj.cookie = NULL;

205. return finish_flatten_binder(NULL, obj, out);

206. }

207. }

208. inline static status_t finish_unflatten_binder(

209. BpBinder* proxy, const flat_binder_object& flat, const Parcel& in)

210. {

211. return NO_ERROR;

212. }

213. status_t unflatten_binder(const sp& proc,

214. const Parcel& in, sp* out)

215. {

216. const flat_binder_object* flat = in.readObject(false);

217. if (flat) {

218. switch (flat->type) {

219. case BINDER_TYPE_BINDER:

220. *out = static_cast<IBinder*>(flat->cookie);

221. return finish_unflatten_binder(NULL, *flat, in);

222. case BINDER_TYPE_HANDLE:

223. *out = proc->getStrongProxyForHandle(flat->handle);

224. return finish_unflatten_binder(

225. static_cast<BpBinder*>(out->get()), *flat, in);

226. }

227. }

228. return BAD_TYPE;

229. }

230. status_t unflatten_binder(const sp& proc,

231. const Parcel& in, wp* out)

232. {

233. const flat_binder_object* flat = in.readObject(false);

234. if (flat) {

235. switch (flat->type) {

236. case BINDER_TYPE_BINDER:

237. *out = static_cast<IBinder*>(flat->cookie);

238. return finish_unflatten_binder(NULL, *flat, in);

239. case BINDER_TYPE_WEAK_BINDER:

240. if (flat->binder != NULL) {

241. out->set_object_and_refs(

242. static_cast<IBinder*>(flat->cookie),

243. static_castRefBase::weakref\_type\*(flat->binder));

244. } else {

245. *out = NULL;

246. }

247. return finish_unflatten_binder(NULL, *flat, in);

248. case BINDER_TYPE_HANDLE:

249. case BINDER_TYPE_WEAK_HANDLE:

250. *out = proc->getWeakProxyForHandle(flat->handle);

251. return finish_unflatten_binder(

252. static_cast<BpBinder*>(out->unsafe_get()), *flat, in);

253. }

254. }

255. return BAD_TYPE;

256. }

257. // ---------------------------------------------------------------------------

258. Parcel::Parcel()

259. {

260. initState();

261. }

262. Parcel::~Parcel()

263. {

264. freeDataNoInit();

265. }

266. const uint8_t* Parcel::data() const

267. {

268. return mData;

269. }

270. size_t Parcel::dataSize() const

271. {

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

273. }

274. size_t Parcel::dataAvail() const

275. {

276. // TODO: decide what to do about the possibility that this can

277. // report an available-data size that exceeds a Java int’s max

278. // positive value, causing havoc.  Fortunately this will only

279. // happen if someone constructs a Parcel containing more than two

280. // gigabytes of data, which on typical phone hardware is simply

281. // not possible.

282. return dataSize() - dataPosition();

283. }

284. size_t Parcel::dataPosition() const

285. {

286. return mDataPos;

287. }

288. size_t Parcel::dataCapacity() const

289. {

290. return mDataCapacity;

291. }

292. status_t Parcel::setDataSize(size_t size)

293. {

294. status_t err;

295. err = continueWrite(size);

296. if (err == NO_ERROR) {

297. mDataSize = size;

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

299. }

300. return err;

301. }

302. void Parcel::setDataPosition(size_t pos) const

303. {

304. mDataPos = pos;

305. mNextObjectHint = 0;

306. }

307. status_t Parcel::setDataCapacity(size_t size)

308. {

309. if (size > mDataSize) return continueWrite(size);

310. return NO_ERROR;

311. }

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

313. {

314. status_t err = restartWrite(len);

315. if (err == NO_ERROR) {

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

317. mDataSize = len;

318. mFdsKnown = false;

319. }

320. return err;

321. }

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

323. {

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

325. status_t err;

326. uint8_t *data = parcel->mData;

327. size_t *objects = parcel->mObjects;

328. size_t size = parcel->mObjectsSize;

329. int startPos = mDataPos;

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

331. if (len == 0) {

332. return NO_ERROR;

333. }

334. // range checks against the source parcel size

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

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

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

338. return BAD_VALUE;

339. }

340. // Count objects in range

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

342. size_t off = objects[i];

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

344. if (firstIndex == -1) {

345. firstIndex = i;

346. }

347. lastIndex = i;

348. }

349. }

350. int numObjects = lastIndex - firstIndex + 1;

351. // grow data

352. err = growData(len);

353. if (err != NO_ERROR) {

354. return err;

355. }

356. // append data

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

358. mDataPos += len;

359. mDataSize += len;

360. if (numObjects > 0) {

361. // grow objects

362. if (mObjectsCapacity < mObjectsSize + numObjects) {

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

364. size_t *objects =

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

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

367. return NO_MEMORY;

368. }

369. mObjects = objects;

370. mObjectsCapacity = newSize;

371. }

372. // append and acquire objects

373. int idx = mObjectsSize;

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

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

376. mObjects[idx++] = off;

377. mObjectsSize++;

378. flat_binder_object* flat

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

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

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

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

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

384. // officially know we have fds.

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

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

387. mHasFds = mFdsKnown = true;

388. }

389. }

390. }

391. return NO_ERROR;

392. }

393. bool Parcel::hasFileDescriptors() const

394. {

395. if (!mFdsKnown) {

396. scanForFds();

397. }

398. return mHasFds;

399. }

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

401. {

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

403. return writeString16(interface);

404. }

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

406. {

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

408. }

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

410. {

411. const String16 str(readString16());

412. if (str == interface) {

413. return true;

414. } else {

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

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

417. return false;

418. }

419. }

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

421. {

422. return mObjects;

423. }

424. size_t Parcel::objectsCount() const

425. {

426. return mObjectsSize;

427. }

428. status_t Parcel::errorCheck() const

429. {

430. return mError;

431. }

432. void Parcel::setError(status_t err)

433. {

434. mError = err;

435. }

436. status_t Parcel::finishWrite(size_t len)

437. {

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

439. mDataPos += len;

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

441. if (mDataPos > mDataSize) {

442. mDataSize = mDataPos;

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

444. }

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

446. return NO_ERROR;

447. }

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

449. {

450. size_t end = mDataPos + len;

451. if (end < mDataPos) {

452. // integer overflow

453. return BAD_VALUE;

454. }

455. if (end <= mDataCapacity) {

456. restart_write:

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

458. return finishWrite(len);

459. }

460. status_t err = growData(len);

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

462. return err;

463. }

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

465. {

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

467. if (d) {

468. memcpy(d, data, len);

469. return NO_ERROR;

470. }

471. return mError;

472. }

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

474. {

475. const size_t padded = PAD_SIZE(len);

476. // sanity check for integer overflow

477. if (mDataPos+padded < mDataPos) {

478. return NULL;

479. }

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

481. restart_write:

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

483. uint8_t* const data = mData+mDataPos;

484. // Need to pad at end?

485. if (padded != len) {

486. #if BYTE_ORDER == BIG_ENDIAN

487. static const uint32_t mask[4] = {

488. 0x00000000, 0xffffff00, 0xffff0000, 0xff000000

489. };

490. #endif

491. #if BYTE_ORDER == LITTLE_ENDIAN

492. static const uint32_t mask[4] = {

493. 0x00000000, 0x00ffffff, 0x0000ffff, 0x000000ff

494. };

495. #endif

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

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

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

499. }

500. finishWrite(padded);

501. return data;

502. }

503. status_t err = growData(padded);

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

505. return NULL;

506. }

507. status_t Parcel::writeInt32(int32_t val)

508. {

509. return writeAligned(val);

510. }

511. status_t Parcel::writeInt64(int64_t val)

512. {

513. return writeAligned(val);

514. }

515. status_t Parcel::writeFloat(float val)

516. {

517. return writeAligned(val);

518. }

519. status_t Parcel::writeDouble(double val)

520. {

521. return writeAligned(val);

522. }

523. status_t Parcel::writeIntPtr(intptr_t val)

524. {

525. return writeAligned(val);

526. }

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

528. {

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

530. }

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

532. {

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

534. if (err == NO_ERROR) {

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

536. }

537. return err;

538. }

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

540. {

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

542. }

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

544. {

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

546. status_t err = writeInt32(len);

547. if (err == NO_ERROR) {

548. len *= sizeof(char16_t);

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

550. if (data) {

551. memcpy(data, str, len);

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

553. return NO_ERROR;

554. }

555. err = mError;

556. }

557. return err;

558. }

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

560. {

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

562. }

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

564. {

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

566. }

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

568. {

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

570. return BAD_TYPE;

571. status_t err;

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

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

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

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

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

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

578. if (err != NO_ERROR) {

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

580. return err;

581. }

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

583. return err;

584. }

585. status_t Parcel::writeFileDescriptor(int fd)

586. {

587. flat_binder_object obj;

588. obj.type = BINDER_TYPE_FD;

589. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;

590. obj.handle = fd;

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

592. return writeObject(obj, true);

593. }

594. status_t Parcel::writeDupFileDescriptor(int fd)

595. {

596. flat_binder_object obj;

597. obj.type = BINDER_TYPE_FD;

598. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;

599. obj.handle = dup(fd);

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

601. return writeObject(obj, true);

602. }

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

604. {

605. status_t err;

606. // size if needed

607. size_t len = val.getFlattenedSize();

608. size_t fd_count = val.getFdCount();

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

610. if (err) return err;

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

612. if (err) return err;

613. // payload

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

615. if (buf == NULL)

616. return BAD_VALUE;

617. int* fds = NULL;

618. if (fd_count) {

619. fds = new int[fd_count];

620. }

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

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

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

624. }

625. if (fd_count) {

626. delete [] fds;

627. }

628. return err;

629. }

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

631. {

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

633. const bool enoughObjects = mObjectsSize < mObjectsCapacity;

634. if (enoughData && enoughObjects) {

635. restart_write:

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

637. // Need to write meta-data?

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

639. mObjects[mObjectsSize] = mDataPos;

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

641. mObjectsSize++;

642. }

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

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

645. mHasFds = mFdsKnown = true;

646. }

647. return finishWrite(sizeof(flat_binder_object));

648. }

649. if (!enoughData) {

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

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

652. }

653. if (!enoughObjects) {

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

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

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

657. mObjects = objects;

658. mObjectsCapacity = newSize;

659. }

660. goto restart_write;

661. }

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

663. {

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

665. }

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

667. {

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

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

670. mDataPos += PAD_SIZE(len);

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

672. return NO_ERROR;

673. }

674. return NOT_ENOUGH_DATA;

675. }

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

677. {

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

679. const void* data = mData+mDataPos;

680. mDataPos += PAD_SIZE(len);

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

682. return data;

683. }

684. return NULL;

685. }

686. template

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

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

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

690. const void* data = mData+mDataPos;

691. mDataPos += sizeof(T);

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

693. return NO_ERROR;

694. } else {

695. return NOT_ENOUGH_DATA;

696. }

697. }

698. template

699. T Parcel::readAligned() const {

700. T result;

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

702. result = 0;

703. }

704. return result;

705. }

706. template

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

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

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

710. restart_write:

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

712. return finishWrite(sizeof(val));

713. }

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

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

716. return err;

717. }

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

719. {

720. return readAligned(pArg);

721. }

722. int32_t Parcel::readInt32() const

723. {

724. return readAligned<int32_t>();

725. }

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

727. {

728. return readAligned(pArg);

729. }

730. int64_t Parcel::readInt64() const

731. {

732. return readAligned<int64_t>();

733. }

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

735. {

736. return readAligned(pArg);

737. }

738. float Parcel::readFloat() const

739. {

740. return readAligned<float>();

741. }

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

743. {

744. return readAligned(pArg);

745. }

746. double Parcel::readDouble() const

747. {

748. return readAligned<double>();

749. }

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

751. {

752. return readAligned(pArg);

753. }

754. intptr_t Parcel::readIntPtr() const

755. {

756. return readAligned<intptr_t>();

757. }

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

759. {

760. const size_t avail = mDataSize-mDataPos;

761. if (avail > 0) {

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

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

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

765. if (eos) {

766. const size_t len = eos - str;

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

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

769. return str;

770. }

771. }

772. return NULL;

773. }

774. String8 Parcel::readString8() const

775. {

776. int32_t size = readInt32();

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

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

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

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

781. }

782. return String8();

783. }

784. String16 Parcel::readString16() const

785. {

786. size_t len;

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

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

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

790. return String16();

791. }

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

793. {

794. int32_t size = readInt32();

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

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

797. *outLen = size;

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

799. if (str != NULL) {

800. return str;

801. }

802. }

803. *outLen = 0;

804. return NULL;

805. }

806. sp Parcel::readStrongBinder() const

807. {

808. sp val;

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

810. return val;

811. }

812. wp Parcel::readWeakBinder() const

813. {

814. wp val;

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

816. return val;

817. }

818. native_handle* Parcel::readNativeHandle() const

819. {

820. int numFds, numInts;

821. status_t err;

822. err = readInt32(&numFds);

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

824. err = readInt32(&numInts);

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

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

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

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

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

830. }

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

832. if (err != NO_ERROR) {

833. native_handle_close(h);

834. native_handle_delete(h);

835. h = 0;

836. }

837. return h;

838. }

839. int Parcel::readFileDescriptor() const

840. {

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

842. if (flat) {

843. switch (flat->type) {

844. case BINDER_TYPE_FD:

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

846. return flat->handle;

847. }

848. }

849. return BAD_TYPE;

850. }

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

852. {

853. // size

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

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

856. // payload

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

858. if (buf == NULL)

859. return BAD_VALUE;

860. int* fds = NULL;

861. if (fd_count) {

862. fds = new int[fd_count];

863. }

864. status_t err = NO_ERROR;

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

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

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

868. }

869. if (err == NO_ERROR) {

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

871. }

872. if (fd_count) {

873. delete [] fds;

874. }

875. return err;

876. }

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

878. {

879. const size_t DPOS = mDataPos;

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

881. const flat_binder_object* obj

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

883. mDataPos = DPOS + sizeof(flat_binder_object);

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

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

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

887. // reading.

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

889. return obj;

890. }

891. // Ensure that this object is valid…

892. size_t* const OBJS = mObjects;

893. const size_t N = mObjectsSize;

894. size_t opos = mNextObjectHint;

895. if (N > 0) {

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

897. this, DPOS, opos);

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

899. // the current data position.

900. if (opos < N) {

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

902. opos++;

903. }

904. } else {

905. opos = N-1;

906. }

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

908. // Found it!

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

910. this, DPOS, opos);

911. mNextObjectHint = opos+1;

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

913. return obj;

914. }

915. // Look backwards for it…

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

917. opos–;

918. }

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

920. // Found it!

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

922. this, DPOS, opos);

923. mNextObjectHint = opos+1;

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

925. return obj;

926. }

927. }

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

929. this, DPOS);

930. }

931. return NULL;

932. }

933. void Parcel::closeFileDescriptors()

934. {

935. size_t i = mObjectsSize;

936. if (i > 0) {

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

938. }

939. while (i > 0) {

940. i–;

941. const flat_binder_object* flat

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

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

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

945. close(flat->handle);

946. }

947. }

948. }

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

950. {

951. return mData;

952. }

953. size_t Parcel::ipcDataSize() const

954. {

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

956. }

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

958. {

959. return mObjects;

960. }

961. size_t Parcel::ipcObjectsCount() const

962. {

963. return mObjectsSize;

964. }

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

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

967. {

968. freeDataNoInit();

969. mError = NO_ERROR;

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

深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）

尾声

评论里面有些同学有疑问关于如何学习material design控件，我的建议是去GitHub搜，有很多同行给的例子，这些栗子足够入门。

有朋友说要是动真格的话，需要NDK以及JVM等的知识，首现**NDK并不是神秘的东西，**你跟着官方的步骤走一遍就知道什么回事了，无非就是一些代码格式以及原生/JAVA内存交互，进阶一点的有原生/JAVA线程交互，线程交互确实有点蛋疼，但平常避免用就好了，再说对于初学者来说关心NDK干嘛，据鄙人以前的经历，只在音视频通信和一个嵌入式信号处理（离线）的两个项目中用过，嵌入式信号处理是JAVA->NDK->.SO->MATLAB这样调用的我原来MATLAB的代码，其他的大多就用在游戏上了吧，一般的互联网公司会有人给你公司的SO包的。
至于JVM,该掌握的那部分，相信我，你会掌握的，不该你掌握的，有那些专门研究JVM的人来做，不如省省心有空看看计算机系统，编译原理。

一句话，平常多写多练，这是最基本的程序员的素质，尽量挤时间，读理论基础书籍，JVM不是未来30年唯一的虚拟机，JAVA也不一定再风靡未来30年工业界，其他的系统和语言也会雨后春笋冒出来，但你理论扎实会让你很快理解学会一个语言或者框架，你平常写的多会让你很快熟练的将新学的东西应用到实际中。
初学者，一句话，多练。

at->handle);

1085. }

1086. }

1087. }

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

1089. {

1090. return mData;

1091. }

1092. size_t Parcel::ipcDataSize() const

1093. {

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

1095. }

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

1097. {

1098. return mObjects;

1099. }

1100. size_t Parcel::ipcObjectsCount() const

1101. {

1102. return mObjectsSize;

1103. }

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

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

1106. {

1107. freeDataNoInit();

1108. mError = NO_ERROR;

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

深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-KLUrssCT-1710507451184)]
[外链图片转存中…(img-95ypRGhr-1710507451185)]
[外链图片转存中…(img-K1NsV9CS-1710507451185)]
[外链图片转存中…(img-zDBe2wTr-1710507451186)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）
[外链图片转存中…(img-jE3ne6Gt-1710507451186)]

尾声

评论里面有些同学有疑问关于如何学习material design控件，我的建议是去GitHub搜，有很多同行给的例子，这些栗子足够入门。

有朋友说要是动真格的话，需要NDK以及JVM等的知识，首现**NDK并不是神秘的东西，**你跟着官方的步骤走一遍就知道什么回事了，无非就是一些代码格式以及原生/JAVA内存交互，进阶一点的有原生/JAVA线程交互，线程交互确实有点蛋疼，但平常避免用就好了，再说对于初学者来说关心NDK干嘛，据鄙人以前的经历，只在音视频通信和一个嵌入式信号处理（离线）的两个项目中用过，嵌入式信号处理是JAVA->NDK->.SO->MATLAB这样调用的我原来MATLAB的代码，其他的大多就用在游戏上了吧，一般的互联网公司会有人给你公司的SO包的。
至于JVM,该掌握的那部分，相信我，你会掌握的，不该你掌握的，有那些专门研究JVM的人来做，不如省省心有空看看计算机系统，编译原理。

一句话，平常多写多练，这是最基本的程序员的素质，尽量挤时间，读理论基础书籍，JVM不是未来30年唯一的虚拟机，JAVA也不一定再风靡未来30年工业界，其他的系统和语言也会雨后春笋冒出来，但你理论扎实会让你很快理解学会一个语言或者框架，你平常写的多会让你很快熟练的将新学的东西应用到实际中。
初学者，一句话，多练。

由于文章篇幅问题复制链接查看详细文章以及获取学习笔记链接：前往我的GitHub