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