android_os_Parcel.cpp revision 90d7a3e996ee3a6e33e655341c5d301fbe30cd58
1/* 2 * Copyright (C) 2012 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#define LOG_TAG "Parcel" 18//#define LOG_NDEBUG 0 19 20#include "android_os_Parcel.h" 21#include "android_util_Binder.h" 22 23#include "JNIHelp.h" 24 25#include <fcntl.h> 26#include <stdio.h> 27#include <sys/stat.h> 28#include <sys/types.h> 29#include <unistd.h> 30 31#include <utils/Atomic.h> 32#include <binder/IInterface.h> 33#include <binder/IPCThreadState.h> 34#include <utils/Log.h> 35#include <utils/SystemClock.h> 36#include <utils/List.h> 37#include <utils/KeyedVector.h> 38#include <binder/Parcel.h> 39#include <binder/ProcessState.h> 40#include <binder/IServiceManager.h> 41#include <utils/threads.h> 42#include <utils/String8.h> 43 44#include <ScopedUtfChars.h> 45#include <ScopedLocalRef.h> 46 47#include <android_runtime/AndroidRuntime.h> 48 49//#undef ALOGV 50//#define ALOGV(...) fprintf(stderr, __VA_ARGS__) 51 52#define DEBUG_DEATH 0 53#if DEBUG_DEATH 54#define LOGDEATH ALOGD 55#else 56#define LOGDEATH ALOGV 57#endif 58 59namespace android { 60 61static struct parcel_offsets_t 62{ 63 jclass clazz; 64 jfieldID mNativePtr; 65 jmethodID obtain; 66 jmethodID recycle; 67} gParcelOffsets; 68 69Parcel* parcelForJavaObject(JNIEnv* env, jobject obj) 70{ 71 if (obj) { 72 Parcel* p = (Parcel*)env->GetLongField(obj, gParcelOffsets.mNativePtr); 73 if (p != NULL) { 74 return p; 75 } 76 jniThrowException(env, "java/lang/IllegalStateException", "Parcel has been finalized!"); 77 } 78 return NULL; 79} 80 81jobject createJavaParcelObject(JNIEnv* env) 82{ 83 return env->CallStaticObjectMethod(gParcelOffsets.clazz, gParcelOffsets.obtain); 84} 85 86void recycleJavaParcelObject(JNIEnv* env, jobject parcelObj) 87{ 88 env->CallVoidMethod(parcelObj, gParcelOffsets.recycle); 89} 90 91static jint android_os_Parcel_dataSize(JNIEnv* env, jclass clazz, jlong nativePtr) 92{ 93 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 94 return parcel ? parcel->dataSize() : 0; 95} 96 97static jint android_os_Parcel_dataAvail(JNIEnv* env, jclass clazz, jlong nativePtr) 98{ 99 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 100 return parcel ? parcel->dataAvail() : 0; 101} 102 103static jint android_os_Parcel_dataPosition(JNIEnv* env, jclass clazz, jlong nativePtr) 104{ 105 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 106 return parcel ? parcel->dataPosition() : 0; 107} 108 109static jint android_os_Parcel_dataCapacity(JNIEnv* env, jclass clazz, jlong nativePtr) 110{ 111 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 112 return parcel ? parcel->dataCapacity() : 0; 113} 114 115static void android_os_Parcel_setDataSize(JNIEnv* env, jclass clazz, jlong nativePtr, jint size) 116{ 117 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 118 if (parcel != NULL) { 119 const status_t err = parcel->setDataSize(size); 120 if (err != NO_ERROR) { 121 signalExceptionForError(env, clazz, err); 122 } 123 } 124} 125 126static void android_os_Parcel_setDataPosition(JNIEnv* env, jclass clazz, jlong nativePtr, jint pos) 127{ 128 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 129 if (parcel != NULL) { 130 parcel->setDataPosition(pos); 131 } 132} 133 134static void android_os_Parcel_setDataCapacity(JNIEnv* env, jclass clazz, jlong nativePtr, jint size) 135{ 136 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 137 if (parcel != NULL) { 138 const status_t err = parcel->setDataCapacity(size); 139 if (err != NO_ERROR) { 140 signalExceptionForError(env, clazz, err); 141 } 142 } 143} 144 145static jboolean android_os_Parcel_pushAllowFds(JNIEnv* env, jclass clazz, jlong nativePtr, jboolean allowFds) 146{ 147 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 148 jboolean ret = JNI_TRUE; 149 if (parcel != NULL) { 150 ret = (jboolean)parcel->pushAllowFds(allowFds); 151 } 152 return ret; 153} 154 155static void android_os_Parcel_restoreAllowFds(JNIEnv* env, jclass clazz, jlong nativePtr, jboolean lastValue) 156{ 157 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 158 if (parcel != NULL) { 159 parcel->restoreAllowFds((bool)lastValue); 160 } 161} 162 163static void android_os_Parcel_writeNative(JNIEnv* env, jclass clazz, jlong nativePtr, jobject data, 164 jint offset, jint length) 165{ 166 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 167 if (parcel == NULL) { 168 return; 169 } 170 171 const status_t err = parcel->writeInt32(length); 172 if (err != NO_ERROR) { 173 signalExceptionForError(env, clazz, err); 174 return; 175 } 176 177 void* dest = parcel->writeInplace(length); 178 if (dest == NULL) { 179 signalExceptionForError(env, clazz, NO_MEMORY); 180 return; 181 } 182 183 jbyte* ar = (jbyte*)env->GetPrimitiveArrayCritical((jarray)data, 0); 184 if (ar) { 185 memcpy(dest, ar + offset, length); 186 env->ReleasePrimitiveArrayCritical((jarray)data, ar, 0); 187 } 188} 189 190static void android_os_Parcel_writeBlob(JNIEnv* env, jclass clazz, jlong nativePtr, jobject data, 191 jint offset, jint length) { 192 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 193 if (parcel == NULL) { 194 return; 195 } 196 197 const status_t err = parcel->writeInt32(length); 198 if (err != NO_ERROR) { 199 signalExceptionForError(env, clazz, err); 200 return; 201 } 202 203 android::Parcel::WritableBlob blob; 204 android::status_t err2 = parcel->writeBlob(length, &blob); 205 if (err2 != NO_ERROR) { 206 signalExceptionForError(env, clazz, err2); 207 return; 208 } 209 210 jbyte* ar = (jbyte*)env->GetPrimitiveArrayCritical((jarray)data, 0); 211 if (ar == NULL) { 212 memset(blob.data(), 0, length); 213 } else { 214 memcpy(blob.data(), ar + offset, length); 215 env->ReleasePrimitiveArrayCritical((jarray)data, ar, 0); 216 } 217 218 blob.release(); 219} 220 221static void android_os_Parcel_writeInt(JNIEnv* env, jclass clazz, jlong nativePtr, jint val) { 222 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 223 const status_t err = parcel->writeInt32(val); 224 if (err != NO_ERROR) { 225 signalExceptionForError(env, clazz, err); 226 } 227} 228 229static void android_os_Parcel_writeLong(JNIEnv* env, jclass clazz, jlong nativePtr, jlong val) 230{ 231 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 232 if (parcel != NULL) { 233 const status_t err = parcel->writeInt64(val); 234 if (err != NO_ERROR) { 235 signalExceptionForError(env, clazz, err); 236 } 237 } 238} 239 240static void android_os_Parcel_writeFloat(JNIEnv* env, jclass clazz, jlong nativePtr, jfloat val) 241{ 242 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 243 if (parcel != NULL) { 244 const status_t err = parcel->writeFloat(val); 245 if (err != NO_ERROR) { 246 signalExceptionForError(env, clazz, err); 247 } 248 } 249} 250 251static void android_os_Parcel_writeDouble(JNIEnv* env, jclass clazz, jlong nativePtr, jdouble val) 252{ 253 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 254 if (parcel != NULL) { 255 const status_t err = parcel->writeDouble(val); 256 if (err != NO_ERROR) { 257 signalExceptionForError(env, clazz, err); 258 } 259 } 260} 261 262static void android_os_Parcel_writeString(JNIEnv* env, jclass clazz, jlong nativePtr, jstring val) 263{ 264 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 265 if (parcel != NULL) { 266 status_t err = NO_MEMORY; 267 if (val) { 268 const jchar* str = env->GetStringCritical(val, 0); 269 if (str) { 270 err = parcel->writeString16(str, env->GetStringLength(val)); 271 env->ReleaseStringCritical(val, str); 272 } 273 } else { 274 err = parcel->writeString16(NULL, 0); 275 } 276 if (err != NO_ERROR) { 277 signalExceptionForError(env, clazz, err); 278 } 279 } 280} 281 282static void android_os_Parcel_writeStrongBinder(JNIEnv* env, jclass clazz, jlong nativePtr, jobject object) 283{ 284 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 285 if (parcel != NULL) { 286 const status_t err = parcel->writeStrongBinder(ibinderForJavaObject(env, object)); 287 if (err != NO_ERROR) { 288 signalExceptionForError(env, clazz, err); 289 } 290 } 291} 292 293static void android_os_Parcel_writeFileDescriptor(JNIEnv* env, jclass clazz, jlong nativePtr, jobject object) 294{ 295 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 296 if (parcel != NULL) { 297 const status_t err = 298 parcel->writeDupFileDescriptor(jniGetFDFromFileDescriptor(env, object)); 299 if (err != NO_ERROR) { 300 signalExceptionForError(env, clazz, err); 301 } 302 } 303} 304 305static jbyteArray android_os_Parcel_createByteArray(JNIEnv* env, jclass clazz, jlong nativePtr) 306{ 307 jbyteArray ret = NULL; 308 309 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 310 if (parcel != NULL) { 311 int32_t len = parcel->readInt32(); 312 313 // sanity check the stored length against the true data size 314 if (len >= 0 && len <= (int32_t)parcel->dataAvail()) { 315 ret = env->NewByteArray(len); 316 317 if (ret != NULL) { 318 jbyte* a2 = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0); 319 if (a2) { 320 const void* data = parcel->readInplace(len); 321 memcpy(a2, data, len); 322 env->ReleasePrimitiveArrayCritical(ret, a2, 0); 323 } 324 } 325 } 326 } 327 328 return ret; 329} 330 331static jbyteArray android_os_Parcel_readBlob(JNIEnv* env, jclass clazz, jlong nativePtr) 332{ 333 jbyteArray ret = NULL; 334 335 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 336 if (parcel != NULL) { 337 int32_t len = parcel->readInt32(); 338 if (len >= 0) { 339 android::Parcel::ReadableBlob blob; 340 android::status_t err = parcel->readBlob(len, &blob); 341 if (err != NO_ERROR) { 342 signalExceptionForError(env, clazz, err); 343 return NULL; 344 } 345 346 ret = env->NewByteArray(len); 347 if (ret != NULL) { 348 jbyte* a2 = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0); 349 if (a2) { 350 memcpy(a2, blob.data(), len); 351 env->ReleasePrimitiveArrayCritical(ret, a2, 0); 352 } 353 } 354 blob.release(); 355 } 356 } 357 358 return ret; 359} 360 361static jint android_os_Parcel_readInt(JNIEnv* env, jclass clazz, jlong nativePtr) 362{ 363 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 364 if (parcel != NULL) { 365 return parcel->readInt32(); 366 } 367 return 0; 368} 369 370static jlong android_os_Parcel_readLong(JNIEnv* env, jclass clazz, jlong nativePtr) 371{ 372 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 373 if (parcel != NULL) { 374 return parcel->readInt64(); 375 } 376 return 0; 377} 378 379static jfloat android_os_Parcel_readFloat(JNIEnv* env, jclass clazz, jlong nativePtr) 380{ 381 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 382 if (parcel != NULL) { 383 return parcel->readFloat(); 384 } 385 return 0; 386} 387 388static jdouble android_os_Parcel_readDouble(JNIEnv* env, jclass clazz, jlong nativePtr) 389{ 390 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 391 if (parcel != NULL) { 392 return parcel->readDouble(); 393 } 394 return 0; 395} 396 397static jstring android_os_Parcel_readString(JNIEnv* env, jclass clazz, jlong nativePtr) 398{ 399 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 400 if (parcel != NULL) { 401 size_t len; 402 const char16_t* str = parcel->readString16Inplace(&len); 403 if (str) { 404 return env->NewString(str, len); 405 } 406 return NULL; 407 } 408 return NULL; 409} 410 411static jobject android_os_Parcel_readStrongBinder(JNIEnv* env, jclass clazz, jlong nativePtr) 412{ 413 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 414 if (parcel != NULL) { 415 return javaObjectForIBinder(env, parcel->readStrongBinder()); 416 } 417 return NULL; 418} 419 420static jobject android_os_Parcel_readFileDescriptor(JNIEnv* env, jclass clazz, jlong nativePtr) 421{ 422 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 423 if (parcel != NULL) { 424 int fd = parcel->readFileDescriptor(); 425 if (fd < 0) return NULL; 426 fd = dup(fd); 427 if (fd < 0) return NULL; 428 return jniCreateFileDescriptor(env, fd); 429 } 430 return NULL; 431} 432 433static jobject android_os_Parcel_openFileDescriptor(JNIEnv* env, jclass clazz, 434 jstring name, jint mode) 435{ 436 if (name == NULL) { 437 jniThrowNullPointerException(env, NULL); 438 return NULL; 439 } 440 const jchar* str = env->GetStringCritical(name, 0); 441 if (str == NULL) { 442 // Whatever, whatever. 443 jniThrowException(env, "java/lang/IllegalStateException", NULL); 444 return NULL; 445 } 446 String8 name8(str, env->GetStringLength(name)); 447 env->ReleaseStringCritical(name, str); 448 int flags=0; 449 switch (mode&0x30000000) { 450 case 0: 451 case 0x10000000: 452 flags = O_RDONLY; 453 break; 454 case 0x20000000: 455 flags = O_WRONLY; 456 break; 457 case 0x30000000: 458 flags = O_RDWR; 459 break; 460 } 461 462 if (mode&0x08000000) flags |= O_CREAT; 463 if (mode&0x04000000) flags |= O_TRUNC; 464 if (mode&0x02000000) flags |= O_APPEND; 465 466 int realMode = S_IRWXU|S_IRWXG; 467 if (mode&0x00000001) realMode |= S_IROTH; 468 if (mode&0x00000002) realMode |= S_IWOTH; 469 470 int fd = open(name8.string(), flags, realMode); 471 if (fd < 0) { 472 jniThrowException(env, "java/io/FileNotFoundException", strerror(errno)); 473 return NULL; 474 } 475 jobject object = jniCreateFileDescriptor(env, fd); 476 if (object == NULL) { 477 close(fd); 478 } 479 return object; 480} 481 482static jobject android_os_Parcel_dupFileDescriptor(JNIEnv* env, jclass clazz, jobject orig) 483{ 484 if (orig == NULL) { 485 jniThrowNullPointerException(env, NULL); 486 return NULL; 487 } 488 int origfd = jniGetFDFromFileDescriptor(env, orig); 489 if (origfd < 0) { 490 jniThrowException(env, "java/lang/IllegalArgumentException", "bad FileDescriptor"); 491 return NULL; 492 } 493 494 int fd = dup(origfd); 495 if (fd < 0) { 496 jniThrowIOException(env, errno); 497 return NULL; 498 } 499 jobject object = jniCreateFileDescriptor(env, fd); 500 if (object == NULL) { 501 close(fd); 502 } 503 return object; 504} 505 506static void android_os_Parcel_closeFileDescriptor(JNIEnv* env, jclass clazz, jobject object) 507{ 508 if (object == NULL) { 509 jniThrowNullPointerException(env, NULL); 510 return; 511 } 512 int fd = jniGetFDFromFileDescriptor(env, object); 513 if (fd >= 0) { 514 jniSetFileDescriptorOfFD(env, object, -1); 515 //ALOGI("Closing ParcelFileDescriptor %d\n", fd); 516 close(fd); 517 } 518} 519 520static void android_os_Parcel_clearFileDescriptor(JNIEnv* env, jclass clazz, jobject object) 521{ 522 if (object == NULL) { 523 jniThrowNullPointerException(env, NULL); 524 return; 525 } 526 int fd = jniGetFDFromFileDescriptor(env, object); 527 if (fd >= 0) { 528 jniSetFileDescriptorOfFD(env, object, -1); 529 } 530} 531 532static jlong android_os_Parcel_create(JNIEnv* env, jclass clazz) 533{ 534 Parcel* parcel = new Parcel(); 535 return reinterpret_cast<jlong>(parcel); 536} 537 538static void android_os_Parcel_freeBuffer(JNIEnv* env, jclass clazz, jlong nativePtr) 539{ 540 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 541 if (parcel != NULL) { 542 parcel->freeData(); 543 } 544} 545 546static void android_os_Parcel_destroy(JNIEnv* env, jclass clazz, jlong nativePtr) 547{ 548 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 549 delete parcel; 550} 551 552static jbyteArray android_os_Parcel_marshall(JNIEnv* env, jclass clazz, jlong nativePtr) 553{ 554 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 555 if (parcel == NULL) { 556 return NULL; 557 } 558 559 // do not marshall if there are binder objects in the parcel 560 if (parcel->objectsCount()) 561 { 562 jniThrowException(env, "java/lang/RuntimeException", "Tried to marshall a Parcel that contained Binder objects."); 563 return NULL; 564 } 565 566 jbyteArray ret = env->NewByteArray(parcel->dataSize()); 567 568 if (ret != NULL) 569 { 570 jbyte* array = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0); 571 if (array != NULL) 572 { 573 memcpy(array, parcel->data(), parcel->dataSize()); 574 env->ReleasePrimitiveArrayCritical(ret, array, 0); 575 } 576 } 577 578 return ret; 579} 580 581static void android_os_Parcel_unmarshall(JNIEnv* env, jclass clazz, jlong nativePtr, 582 jbyteArray data, jint offset, jint length) 583{ 584 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 585 if (parcel == NULL || length < 0) { 586 return; 587 } 588 589 jbyte* array = (jbyte*)env->GetPrimitiveArrayCritical(data, 0); 590 if (array) 591 { 592 parcel->setDataSize(length); 593 parcel->setDataPosition(0); 594 595 void* raw = parcel->writeInplace(length); 596 memcpy(raw, (array + offset), length); 597 598 env->ReleasePrimitiveArrayCritical(data, array, 0); 599 } 600} 601 602static void android_os_Parcel_appendFrom(JNIEnv* env, jclass clazz, jlong thisNativePtr, 603 jlong otherNativePtr, jint offset, jint length) 604{ 605 Parcel* thisParcel = reinterpret_cast<Parcel*>(thisNativePtr); 606 if (thisParcel == NULL) { 607 return; 608 } 609 Parcel* otherParcel = reinterpret_cast<Parcel*>(otherNativePtr); 610 if (otherParcel == NULL) { 611 return; 612 } 613 614 status_t err = thisParcel->appendFrom(otherParcel, offset, length); 615 if (err != NO_ERROR) { 616 signalExceptionForError(env, clazz, err); 617 } 618} 619 620static jboolean android_os_Parcel_hasFileDescriptors(JNIEnv* env, jclass clazz, jlong nativePtr) 621{ 622 jboolean ret = JNI_FALSE; 623 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 624 if (parcel != NULL) { 625 if (parcel->hasFileDescriptors()) { 626 ret = JNI_TRUE; 627 } 628 } 629 return ret; 630} 631 632static void android_os_Parcel_writeInterfaceToken(JNIEnv* env, jclass clazz, jlong nativePtr, 633 jstring name) 634{ 635 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 636 if (parcel != NULL) { 637 // In the current implementation, the token is just the serialized interface name that 638 // the caller expects to be invoking 639 const jchar* str = env->GetStringCritical(name, 0); 640 if (str != NULL) { 641 parcel->writeInterfaceToken(String16(str, env->GetStringLength(name))); 642 env->ReleaseStringCritical(name, str); 643 } 644 } 645} 646 647static void android_os_Parcel_enforceInterface(JNIEnv* env, jclass clazz, jlong nativePtr, jstring name) 648{ 649 jboolean ret = JNI_FALSE; 650 651 Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 652 if (parcel != NULL) { 653 const jchar* str = env->GetStringCritical(name, 0); 654 if (str) { 655 IPCThreadState* threadState = IPCThreadState::self(); 656 const int32_t oldPolicy = threadState->getStrictModePolicy(); 657 const bool isValid = parcel->enforceInterface( 658 String16(str, env->GetStringLength(name)), 659 threadState); 660 env->ReleaseStringCritical(name, str); 661 if (isValid) { 662 const int32_t newPolicy = threadState->getStrictModePolicy(); 663 if (oldPolicy != newPolicy) { 664 // Need to keep the Java-level thread-local strict 665 // mode policy in sync for the libcore 666 // enforcements, which involves an upcall back 667 // into Java. (We can't modify the 668 // Parcel.enforceInterface signature, as it's 669 // pseudo-public, and used via AIDL 670 // auto-generation...) 671 set_dalvik_blockguard_policy(env, newPolicy); 672 } 673 return; // everything was correct -> return silently 674 } 675 } 676 } 677 678 // all error conditions wind up here 679 jniThrowException(env, "java/lang/SecurityException", 680 "Binder invocation to an incorrect interface"); 681} 682 683// ---------------------------------------------------------------------------- 684 685static const JNINativeMethod gParcelMethods[] = { 686 {"nativeDataSize", "(J)I", (void*)android_os_Parcel_dataSize}, 687 {"nativeDataAvail", "(J)I", (void*)android_os_Parcel_dataAvail}, 688 {"nativeDataPosition", "(J)I", (void*)android_os_Parcel_dataPosition}, 689 {"nativeDataCapacity", "(J)I", (void*)android_os_Parcel_dataCapacity}, 690 {"nativeSetDataSize", "(JI)V", (void*)android_os_Parcel_setDataSize}, 691 {"nativeSetDataPosition", "(JI)V", (void*)android_os_Parcel_setDataPosition}, 692 {"nativeSetDataCapacity", "(JI)V", (void*)android_os_Parcel_setDataCapacity}, 693 694 {"nativePushAllowFds", "(JZ)Z", (void*)android_os_Parcel_pushAllowFds}, 695 {"nativeRestoreAllowFds", "(JZ)V", (void*)android_os_Parcel_restoreAllowFds}, 696 697 {"nativeWriteByteArray", "(J[BII)V", (void*)android_os_Parcel_writeNative}, 698 {"nativeWriteBlob", "(J[BII)V", (void*)android_os_Parcel_writeBlob}, 699 {"nativeWriteInt", "(JI)V", (void*)android_os_Parcel_writeInt}, 700 {"nativeWriteLong", "(JJ)V", (void*)android_os_Parcel_writeLong}, 701 {"nativeWriteFloat", "(JF)V", (void*)android_os_Parcel_writeFloat}, 702 {"nativeWriteDouble", "(JD)V", (void*)android_os_Parcel_writeDouble}, 703 {"nativeWriteString", "(JLjava/lang/String;)V", (void*)android_os_Parcel_writeString}, 704 {"nativeWriteStrongBinder", "(JLandroid/os/IBinder;)V", (void*)android_os_Parcel_writeStrongBinder}, 705 {"nativeWriteFileDescriptor", "(JLjava/io/FileDescriptor;)V", (void*)android_os_Parcel_writeFileDescriptor}, 706 707 {"nativeCreateByteArray", "(J)[B", (void*)android_os_Parcel_createByteArray}, 708 {"nativeReadBlob", "(J)[B", (void*)android_os_Parcel_readBlob}, 709 {"nativeReadInt", "(J)I", (void*)android_os_Parcel_readInt}, 710 {"nativeReadLong", "(J)J", (void*)android_os_Parcel_readLong}, 711 {"nativeReadFloat", "(J)F", (void*)android_os_Parcel_readFloat}, 712 {"nativeReadDouble", "(J)D", (void*)android_os_Parcel_readDouble}, 713 {"nativeReadString", "(J)Ljava/lang/String;", (void*)android_os_Parcel_readString}, 714 {"nativeReadStrongBinder", "(J)Landroid/os/IBinder;", (void*)android_os_Parcel_readStrongBinder}, 715 {"nativeReadFileDescriptor", "(J)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_readFileDescriptor}, 716 717 {"openFileDescriptor", "(Ljava/lang/String;I)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_openFileDescriptor}, 718 {"dupFileDescriptor", "(Ljava/io/FileDescriptor;)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_dupFileDescriptor}, 719 {"closeFileDescriptor", "(Ljava/io/FileDescriptor;)V", (void*)android_os_Parcel_closeFileDescriptor}, 720 {"clearFileDescriptor", "(Ljava/io/FileDescriptor;)V", (void*)android_os_Parcel_clearFileDescriptor}, 721 722 {"nativeCreate", "()J", (void*)android_os_Parcel_create}, 723 {"nativeFreeBuffer", "(J)V", (void*)android_os_Parcel_freeBuffer}, 724 {"nativeDestroy", "(J)V", (void*)android_os_Parcel_destroy}, 725 726 {"nativeMarshall", "(J)[B", (void*)android_os_Parcel_marshall}, 727 {"nativeUnmarshall", "(J[BII)V", (void*)android_os_Parcel_unmarshall}, 728 {"nativeAppendFrom", "(JJII)V", (void*)android_os_Parcel_appendFrom}, 729 {"nativeHasFileDescriptors", "(J)Z", (void*)android_os_Parcel_hasFileDescriptors}, 730 {"nativeWriteInterfaceToken", "(JLjava/lang/String;)V", (void*)android_os_Parcel_writeInterfaceToken}, 731 {"nativeEnforceInterface", "(JLjava/lang/String;)V", (void*)android_os_Parcel_enforceInterface}, 732}; 733 734const char* const kParcelPathName = "android/os/Parcel"; 735 736int register_android_os_Parcel(JNIEnv* env) 737{ 738 jclass clazz; 739 740 clazz = env->FindClass(kParcelPathName); 741 LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.Parcel"); 742 743 gParcelOffsets.clazz = (jclass) env->NewGlobalRef(clazz); 744 gParcelOffsets.mNativePtr = env->GetFieldID(clazz, "mNativePtr", "J"); 745 gParcelOffsets.obtain = env->GetStaticMethodID(clazz, "obtain", 746 "()Landroid/os/Parcel;"); 747 gParcelOffsets.recycle = env->GetMethodID(clazz, "recycle", "()V"); 748 749 return AndroidRuntime::registerNativeMethods( 750 env, kParcelPathName, 751 gParcelMethods, NELEM(gParcelMethods)); 752} 753 754}; 755