android_os_Parcel.cpp revision 387116f557c3d3ecf7bd82e1d9dd1910ca4c4a3d 
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, &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    const status_t err = parcel->writeInt32(val);
234    if (err != NO_ERROR) {
235        signalExceptionForError(env, clazz, err);
236    }
237}
238
239static void android_os_Parcel_writeLong(JNIEnv* env, jclass clazz, jlong nativePtr, jlong val)
240{
241    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
242    if (parcel != NULL) {
243        const status_t err = parcel->writeInt64(val);
244        if (err != NO_ERROR) {
245            signalExceptionForError(env, clazz, err);
246        }
247    }
248}
249
250static void android_os_Parcel_writeFloat(JNIEnv* env, jclass clazz, jlong nativePtr, jfloat val)
251{
252    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
253    if (parcel != NULL) {
254        const status_t err = parcel->writeFloat(val);
255        if (err != NO_ERROR) {
256            signalExceptionForError(env, clazz, err);
257        }
258    }
259}
260
261static void android_os_Parcel_writeDouble(JNIEnv* env, jclass clazz, jlong nativePtr, jdouble val)
262{
263    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
264    if (parcel != NULL) {
265        const status_t err = parcel->writeDouble(val);
266        if (err != NO_ERROR) {
267            signalExceptionForError(env, clazz, err);
268        }
269    }
270}
271
272static void android_os_Parcel_writeString(JNIEnv* env, jclass clazz, jlong nativePtr, jstring val)
273{
274    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
275    if (parcel != NULL) {
276        status_t err = NO_MEMORY;
277        if (val) {
278            const jchar* str = env->GetStringCritical(val, 0);
279            if (str) {
280                err = parcel->writeString16(str, env->GetStringLength(val));
281                env->ReleaseStringCritical(val, str);
282            }
283        } else {
284            err = parcel->writeString16(NULL, 0);
285        }
286        if (err != NO_ERROR) {
287            signalExceptionForError(env, clazz, err);
288        }
289    }
290}
291
292static void android_os_Parcel_writeStrongBinder(JNIEnv* env, jclass clazz, jlong nativePtr, jobject object)
293{
294    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
295    if (parcel != NULL) {
296        const status_t err = parcel->writeStrongBinder(ibinderForJavaObject(env, object));
297        if (err != NO_ERROR) {
298            signalExceptionForError(env, clazz, err);
299        }
300    }
301}
302
303static void android_os_Parcel_writeFileDescriptor(JNIEnv* env, jclass clazz, jlong nativePtr, jobject object)
304{
305    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
306    if (parcel != NULL) {
307        const status_t err =
308                parcel->writeDupFileDescriptor(jniGetFDFromFileDescriptor(env, object));
309        if (err != NO_ERROR) {
310            signalExceptionForError(env, clazz, err);
311        }
312    }
313}
314
315static jbyteArray android_os_Parcel_createByteArray(JNIEnv* env, jclass clazz, jlong nativePtr)
316{
317    jbyteArray ret = NULL;
318
319    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
320    if (parcel != NULL) {
321        int32_t len = parcel->readInt32();
322
323        // sanity check the stored length against the true data size
324        if (len >= 0 && len <= (int32_t)parcel->dataAvail()) {
325            ret = env->NewByteArray(len);
326
327            if (ret != NULL) {
328                jbyte* a2 = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0);
329                if (a2) {
330                    const void* data = parcel->readInplace(len);
331                    memcpy(a2, data, len);
332                    env->ReleasePrimitiveArrayCritical(ret, a2, 0);
333                }
334            }
335        }
336    }
337
338    return ret;
339}
340
341static jbyteArray android_os_Parcel_readBlob(JNIEnv* env, jclass clazz, jlong nativePtr)
342{
343    jbyteArray ret = NULL;
344
345    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
346    if (parcel != NULL) {
347        int32_t len = parcel->readInt32();
348        if (len >= 0) {
349            android::Parcel::ReadableBlob blob;
350            android::status_t err = parcel->readBlob(len, &blob);
351            if (err != NO_ERROR) {
352                signalExceptionForError(env, clazz, err);
353                return NULL;
354            }
355
356            ret = env->NewByteArray(len);
357            if (ret != NULL) {
358                jbyte* a2 = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0);
359                if (a2) {
360                    memcpy(a2, blob.data(), len);
361                    env->ReleasePrimitiveArrayCritical(ret, a2, 0);
362                }
363            }
364            blob.release();
365        }
366    }
367
368    return ret;
369}
370
371static jint android_os_Parcel_readInt(JNIEnv* env, jclass clazz, jlong nativePtr)
372{
373    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
374    if (parcel != NULL) {
375        return parcel->readInt32();
376    }
377    return 0;
378}
379
380static jlong android_os_Parcel_readLong(JNIEnv* env, jclass clazz, jlong nativePtr)
381{
382    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
383    if (parcel != NULL) {
384        return parcel->readInt64();
385    }
386    return 0;
387}
388
389static jfloat android_os_Parcel_readFloat(JNIEnv* env, jclass clazz, jlong nativePtr)
390{
391    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
392    if (parcel != NULL) {
393        return parcel->readFloat();
394    }
395    return 0;
396}
397
398static jdouble android_os_Parcel_readDouble(JNIEnv* env, jclass clazz, jlong nativePtr)
399{
400    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
401    if (parcel != NULL) {
402        return parcel->readDouble();
403    }
404    return 0;
405}
406
407static jstring android_os_Parcel_readString(JNIEnv* env, jclass clazz, jlong nativePtr)
408{
409    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
410    if (parcel != NULL) {
411        size_t len;
412        const char16_t* str = parcel->readString16Inplace(&len);
413        if (str) {
414            return env->NewString(str, len);
415        }
416        return NULL;
417    }
418    return NULL;
419}
420
421static jobject android_os_Parcel_readStrongBinder(JNIEnv* env, jclass clazz, jlong nativePtr)
422{
423    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
424    if (parcel != NULL) {
425        return javaObjectForIBinder(env, parcel->readStrongBinder());
426    }
427    return NULL;
428}
429
430static jobject android_os_Parcel_readFileDescriptor(JNIEnv* env, jclass clazz, jlong nativePtr)
431{
432    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
433    if (parcel != NULL) {
434        int fd = parcel->readFileDescriptor();
435        if (fd < 0) return NULL;
436        fd = dup(fd);
437        if (fd < 0) return NULL;
438        return jniCreateFileDescriptor(env, fd);
439    }
440    return NULL;
441}
442
443static jobject android_os_Parcel_openFileDescriptor(JNIEnv* env, jclass clazz,
444                                                    jstring name, jint mode)
445{
446    if (name == NULL) {
447        jniThrowNullPointerException(env, NULL);
448        return NULL;
449    }
450    const jchar* str = env->GetStringCritical(name, 0);
451    if (str == NULL) {
452        // Whatever, whatever.
453        jniThrowException(env, "java/lang/IllegalStateException", NULL);
454        return NULL;
455    }
456    String8 name8(str, env->GetStringLength(name));
457    env->ReleaseStringCritical(name, str);
458    int flags=0;
459    switch (mode&0x30000000) {
460        case 0:
461        case 0x10000000:
462            flags = O_RDONLY;
463            break;
464        case 0x20000000:
465            flags = O_WRONLY;
466            break;
467        case 0x30000000:
468            flags = O_RDWR;
469            break;
470    }
471
472    if (mode&0x08000000) flags |= O_CREAT;
473    if (mode&0x04000000) flags |= O_TRUNC;
474    if (mode&0x02000000) flags |= O_APPEND;
475
476    int realMode = S_IRWXU|S_IRWXG;
477    if (mode&0x00000001) realMode |= S_IROTH;
478    if (mode&0x00000002) realMode |= S_IWOTH;
479
480    int fd = open(name8.string(), flags, realMode);
481    if (fd < 0) {
482        jniThrowException(env, "java/io/FileNotFoundException", strerror(errno));
483        return NULL;
484    }
485    jobject object = jniCreateFileDescriptor(env, fd);
486    if (object == NULL) {
487        close(fd);
488    }
489    return object;
490}
491
492static jobject android_os_Parcel_dupFileDescriptor(JNIEnv* env, jclass clazz, jobject orig)
493{
494    if (orig == NULL) {
495        jniThrowNullPointerException(env, NULL);
496        return NULL;
497    }
498    int origfd = jniGetFDFromFileDescriptor(env, orig);
499    if (origfd < 0) {
500        jniThrowException(env, "java/lang/IllegalArgumentException", "bad FileDescriptor");
501        return NULL;
502    }
503
504    int fd = dup(origfd);
505    if (fd < 0) {
506        jniThrowIOException(env, errno);
507        return NULL;
508    }
509    jobject object = jniCreateFileDescriptor(env, fd);
510    if (object == NULL) {
511        close(fd);
512    }
513    return object;
514}
515
516static void android_os_Parcel_closeFileDescriptor(JNIEnv* env, jclass clazz, jobject object)
517{
518    if (object == NULL) {
519        jniThrowNullPointerException(env, NULL);
520        return;
521    }
522    int fd = jniGetFDFromFileDescriptor(env, object);
523    if (fd >= 0) {
524        jniSetFileDescriptorOfFD(env, object, -1);
525        //ALOGI("Closing ParcelFileDescriptor %d\n", fd);
526        close(fd);
527    }
528}
529
530static void android_os_Parcel_clearFileDescriptor(JNIEnv* env, jclass clazz, jobject object)
531{
532    if (object == NULL) {
533        jniThrowNullPointerException(env, NULL);
534        return;
535    }
536    int fd = jniGetFDFromFileDescriptor(env, object);
537    if (fd >= 0) {
538        jniSetFileDescriptorOfFD(env, object, -1);
539    }
540}
541
542static jlong android_os_Parcel_create(JNIEnv* env, jclass clazz)
543{
544    Parcel* parcel = new Parcel();
545    return reinterpret_cast<jlong>(parcel);
546}
547
548static void android_os_Parcel_freeBuffer(JNIEnv* env, jclass clazz, jlong nativePtr)
549{
550    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
551    if (parcel != NULL) {
552        parcel->freeData();
553    }
554}
555
556static void android_os_Parcel_destroy(JNIEnv* env, jclass clazz, jlong nativePtr)
557{
558    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
559    delete parcel;
560}
561
562static jbyteArray android_os_Parcel_marshall(JNIEnv* env, jclass clazz, jlong nativePtr)
563{
564    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
565    if (parcel == NULL) {
566       return NULL;
567    }
568
569    // do not marshall if there are binder objects in the parcel
570    if (parcel->objectsCount())
571    {
572        jniThrowException(env, "java/lang/RuntimeException", "Tried to marshall a Parcel that contained Binder objects.");
573        return NULL;
574    }
575
576    jbyteArray ret = env->NewByteArray(parcel->dataSize());
577
578    if (ret != NULL)
579    {
580        jbyte* array = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0);
581        if (array != NULL)
582        {
583            memcpy(array, parcel->data(), parcel->dataSize());
584            env->ReleasePrimitiveArrayCritical(ret, array, 0);
585        }
586    }
587
588    return ret;
589}
590
591static void android_os_Parcel_unmarshall(JNIEnv* env, jclass clazz, jlong nativePtr,
592                                         jbyteArray data, jint offset, jint length)
593{
594    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
595    if (parcel == NULL || length < 0) {
596       return;
597    }
598
599    jbyte* array = (jbyte*)env->GetPrimitiveArrayCritical(data, 0);
600    if (array)
601    {
602        parcel->setDataSize(length);
603        parcel->setDataPosition(0);
604
605        void* raw = parcel->writeInplace(length);
606        memcpy(raw, (array + offset), length);
607
608        env->ReleasePrimitiveArrayCritical(data, array, 0);
609    }
610}
611
612static void android_os_Parcel_appendFrom(JNIEnv* env, jclass clazz, jlong thisNativePtr,
613                                         jlong otherNativePtr, jint offset, jint length)
614{
615    Parcel* thisParcel = reinterpret_cast<Parcel*>(thisNativePtr);
616    if (thisParcel == NULL) {
617       return;
618    }
619    Parcel* otherParcel = reinterpret_cast<Parcel*>(otherNativePtr);
620    if (otherParcel == NULL) {
621       return;
622    }
623
624    status_t err = thisParcel->appendFrom(otherParcel, offset, length);
625    if (err != NO_ERROR) {
626        signalExceptionForError(env, clazz, err);
627    }
628}
629
630static jboolean android_os_Parcel_hasFileDescriptors(JNIEnv* env, jclass clazz, jlong nativePtr)
631{
632    jboolean ret = JNI_FALSE;
633    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
634    if (parcel != NULL) {
635        if (parcel->hasFileDescriptors()) {
636            ret = JNI_TRUE;
637        }
638    }
639    return ret;
640}
641
642static void android_os_Parcel_writeInterfaceToken(JNIEnv* env, jclass clazz, jlong nativePtr,
643                                                  jstring name)
644{
645    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
646    if (parcel != NULL) {
647        // In the current implementation, the token is just the serialized interface name that
648        // the caller expects to be invoking
649        const jchar* str = env->GetStringCritical(name, 0);
650        if (str != NULL) {
651            parcel->writeInterfaceToken(String16(str, env->GetStringLength(name)));
652            env->ReleaseStringCritical(name, str);
653        }
654    }
655}
656
657static void android_os_Parcel_enforceInterface(JNIEnv* env, jclass clazz, jlong nativePtr, jstring name)
658{
659    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
660    if (parcel != NULL) {
661        const jchar* str = env->GetStringCritical(name, 0);
662        if (str) {
663            IPCThreadState* threadState = IPCThreadState::self();
664            const int32_t oldPolicy = threadState->getStrictModePolicy();
665            const bool isValid = parcel->enforceInterface(
666                String16(str, env->GetStringLength(name)),
667                threadState);
668            env->ReleaseStringCritical(name, str);
669            if (isValid) {
670                const int32_t newPolicy = threadState->getStrictModePolicy();
671                if (oldPolicy != newPolicy) {
672                    // Need to keep the Java-level thread-local strict
673                    // mode policy in sync for the libcore
674                    // enforcements, which involves an upcall back
675                    // into Java.  (We can't modify the
676                    // Parcel.enforceInterface signature, as it's
677                    // pseudo-public, and used via AIDL
678                    // auto-generation...)
679                    set_dalvik_blockguard_policy(env, newPolicy);
680                }
681                return;     // everything was correct -> return silently
682            }
683        }
684    }
685
686    // all error conditions wind up here
687    jniThrowException(env, "java/lang/SecurityException",
688            "Binder invocation to an incorrect interface");
689}
690
691static jlong android_os_Parcel_getGlobalAllocSize(JNIEnv* env, jclass clazz)
692{
693    return Parcel::getGlobalAllocSize();
694}
695
696static jlong android_os_Parcel_getGlobalAllocCount(JNIEnv* env, jclass clazz)
697{
698    return Parcel::getGlobalAllocCount();
699}
700
701// ----------------------------------------------------------------------------
702
703static const JNINativeMethod gParcelMethods[] = {
704    {"nativeDataSize",            "(J)I", (void*)android_os_Parcel_dataSize},
705    {"nativeDataAvail",           "(J)I", (void*)android_os_Parcel_dataAvail},
706    {"nativeDataPosition",        "(J)I", (void*)android_os_Parcel_dataPosition},
707    {"nativeDataCapacity",        "(J)I", (void*)android_os_Parcel_dataCapacity},
708    {"nativeSetDataSize",         "(JI)V", (void*)android_os_Parcel_setDataSize},
709    {"nativeSetDataPosition",     "(JI)V", (void*)android_os_Parcel_setDataPosition},
710    {"nativeSetDataCapacity",     "(JI)V", (void*)android_os_Parcel_setDataCapacity},
711
712    {"nativePushAllowFds",        "(JZ)Z", (void*)android_os_Parcel_pushAllowFds},
713    {"nativeRestoreAllowFds",     "(JZ)V", (void*)android_os_Parcel_restoreAllowFds},
714
715    {"nativeWriteByteArray",      "(J[BII)V", (void*)android_os_Parcel_writeNative},
716    {"nativeWriteBlob",           "(J[BII)V", (void*)android_os_Parcel_writeBlob},
717    {"nativeWriteInt",            "(JI)V", (void*)android_os_Parcel_writeInt},
718    {"nativeWriteLong",           "(JJ)V", (void*)android_os_Parcel_writeLong},
719    {"nativeWriteFloat",          "(JF)V", (void*)android_os_Parcel_writeFloat},
720    {"nativeWriteDouble",         "(JD)V", (void*)android_os_Parcel_writeDouble},
721    {"nativeWriteString",         "(JLjava/lang/String;)V", (void*)android_os_Parcel_writeString},
722    {"nativeWriteStrongBinder",   "(JLandroid/os/IBinder;)V", (void*)android_os_Parcel_writeStrongBinder},
723    {"nativeWriteFileDescriptor", "(JLjava/io/FileDescriptor;)V", (void*)android_os_Parcel_writeFileDescriptor},
724
725    {"nativeCreateByteArray",     "(J)[B", (void*)android_os_Parcel_createByteArray},
726    {"nativeReadBlob",            "(J)[B", (void*)android_os_Parcel_readBlob},
727    {"nativeReadInt",             "(J)I", (void*)android_os_Parcel_readInt},
728    {"nativeReadLong",            "(J)J", (void*)android_os_Parcel_readLong},
729    {"nativeReadFloat",           "(J)F", (void*)android_os_Parcel_readFloat},
730    {"nativeReadDouble",          "(J)D", (void*)android_os_Parcel_readDouble},
731    {"nativeReadString",          "(J)Ljava/lang/String;", (void*)android_os_Parcel_readString},
732    {"nativeReadStrongBinder",    "(J)Landroid/os/IBinder;", (void*)android_os_Parcel_readStrongBinder},
733    {"nativeReadFileDescriptor",  "(J)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_readFileDescriptor},
734
735    {"openFileDescriptor",        "(Ljava/lang/String;I)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_openFileDescriptor},
736    {"dupFileDescriptor",         "(Ljava/io/FileDescriptor;)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_dupFileDescriptor},
737    {"closeFileDescriptor",       "(Ljava/io/FileDescriptor;)V", (void*)android_os_Parcel_closeFileDescriptor},
738    {"clearFileDescriptor",       "(Ljava/io/FileDescriptor;)V", (void*)android_os_Parcel_clearFileDescriptor},
739
740    {"nativeCreate",              "()J", (void*)android_os_Parcel_create},
741    {"nativeFreeBuffer",          "(J)V", (void*)android_os_Parcel_freeBuffer},
742    {"nativeDestroy",             "(J)V", (void*)android_os_Parcel_destroy},
743
744    {"nativeMarshall",            "(J)[B", (void*)android_os_Parcel_marshall},
745    {"nativeUnmarshall",          "(J[BII)V", (void*)android_os_Parcel_unmarshall},
746    {"nativeAppendFrom",          "(JJII)V", (void*)android_os_Parcel_appendFrom},
747    {"nativeHasFileDescriptors",  "(J)Z", (void*)android_os_Parcel_hasFileDescriptors},
748    {"nativeWriteInterfaceToken", "(JLjava/lang/String;)V", (void*)android_os_Parcel_writeInterfaceToken},
749    {"nativeEnforceInterface",    "(JLjava/lang/String;)V", (void*)android_os_Parcel_enforceInterface},
750
751    {"getGlobalAllocSize",        "()J", (void*)android_os_Parcel_getGlobalAllocSize},
752    {"getGlobalAllocCount",       "()J", (void*)android_os_Parcel_getGlobalAllocCount},
753};
754
755const char* const kParcelPathName = "android/os/Parcel";
756
757int register_android_os_Parcel(JNIEnv* env)
758{
759    jclass clazz = FindClassOrDie(env, kParcelPathName);
760
761    gParcelOffsets.clazz = MakeGlobalRefOrDie(env, clazz);
762    gParcelOffsets.mNativePtr = GetFieldIDOrDie(env, clazz, "mNativePtr", "J");
763    gParcelOffsets.obtain = GetStaticMethodIDOrDie(env, clazz, "obtain", "()Landroid/os/Parcel;");
764    gParcelOffsets.recycle = GetMethodIDOrDie(env, clazz, "recycle", "()V");
765
766    return RegisterMethodsOrDie(env, kParcelPathName, gParcelMethods, NELEM(gParcelMethods));
767}
768
769};
770