1 /* 2 * Copyright (C) 2010 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 #ifndef SCOPED_PRIMITIVE_ARRAY_H_included 18 #define SCOPED_PRIMITIVE_ARRAY_H_included 19 20 #include "JNIHelp.h" 21 22 // ScopedBooleanArrayRO, ScopedByteArrayRO, ScopedCharArrayRO, ScopedDoubleArrayRO, 23 // ScopedFloatArrayRO, ScopedIntArrayRO, ScopedLongArrayRO, and ScopedShortArrayRO provide 24 // convenient read-only access to Java arrays from JNI code. This is cheaper than read-write 25 // access and should be used by default. 26 #define INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RO(PRIMITIVE_TYPE, NAME) \ 27 class Scoped ## NAME ## ArrayRO { \ 28 public: \ 29 explicit Scoped ## NAME ## ArrayRO(JNIEnv* env) \ 30 : mEnv(env), mJavaArray(NULL), mRawArray(NULL), mSize(0) {} \ 31 Scoped ## NAME ## ArrayRO(JNIEnv* env, PRIMITIVE_TYPE ## Array javaArray) \ 32 : mEnv(env) { \ 33 if (javaArray == NULL) { \ 34 mJavaArray = NULL; \ 35 mSize = 0; \ 36 mRawArray = NULL; \ 37 jniThrowNullPointerException(mEnv, NULL); \ 38 } else { \ 39 reset(javaArray); \ 40 } \ 41 } \ 42 ~Scoped ## NAME ## ArrayRO() { \ 43 if (mRawArray != NULL && mRawArray != mBuffer) { \ 44 mEnv->Release ## NAME ## ArrayElements(mJavaArray, mRawArray, JNI_ABORT); \ 45 } \ 46 } \ 47 void reset(PRIMITIVE_TYPE ## Array javaArray) { \ 48 mJavaArray = javaArray; \ 49 mSize = mEnv->GetArrayLength(mJavaArray); \ 50 if (mSize <= buffer_size) { \ 51 mEnv->Get ## NAME ## ArrayRegion(mJavaArray, 0, mSize, mBuffer); \ 52 mRawArray = mBuffer; \ 53 } else { \ 54 mRawArray = mEnv->Get ## NAME ## ArrayElements(mJavaArray, NULL); \ 55 } \ 56 } \ 57 const PRIMITIVE_TYPE* get() const { return mRawArray; } \ 58 PRIMITIVE_TYPE ## Array getJavaArray() const { return mJavaArray; } \ 59 const PRIMITIVE_TYPE& operator[](size_t n) const { return mRawArray[n]; } \ 60 size_t size() const { return mSize; } \ 61 private: \ 62 static const jsize buffer_size = 1024; \ 63 JNIEnv* const mEnv; \ 64 PRIMITIVE_TYPE ## Array mJavaArray; \ 65 PRIMITIVE_TYPE* mRawArray; \ 66 jsize mSize; \ 67 PRIMITIVE_TYPE mBuffer[buffer_size]; \ 68 DISALLOW_COPY_AND_ASSIGN(Scoped ## NAME ## ArrayRO); \ 69 } 70 71 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RO(jboolean, Boolean); 72 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RO(jbyte, Byte); 73 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RO(jchar, Char); 74 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RO(jdouble, Double); 75 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RO(jfloat, Float); 76 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RO(jint, Int); 77 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RO(jlong, Long); 78 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RO(jshort, Short); 79 80 #undef INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RO 81 82 // ScopedBooleanArrayRW, ScopedByteArrayRW, ScopedCharArrayRW, ScopedDoubleArrayRW, 83 // ScopedFloatArrayRW, ScopedIntArrayRW, ScopedLongArrayRW, and ScopedShortArrayRW provide 84 // convenient read-write access to Java arrays from JNI code. These are more expensive, 85 // since they entail a copy back onto the Java heap, and should only be used when necessary. 86 #define INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RW(PRIMITIVE_TYPE, NAME) \ 87 class Scoped ## NAME ## ArrayRW { \ 88 public: \ 89 explicit Scoped ## NAME ## ArrayRW(JNIEnv* env) \ 90 : mEnv(env), mJavaArray(NULL), mRawArray(NULL) {} \ 91 Scoped ## NAME ## ArrayRW(JNIEnv* env, PRIMITIVE_TYPE ## Array javaArray) \ 92 : mEnv(env), mJavaArray(javaArray), mRawArray(NULL) { \ 93 if (mJavaArray == NULL) { \ 94 jniThrowNullPointerException(mEnv, NULL); \ 95 } else { \ 96 mRawArray = mEnv->Get ## NAME ## ArrayElements(mJavaArray, NULL); \ 97 } \ 98 } \ 99 ~Scoped ## NAME ## ArrayRW() { \ 100 if (mRawArray) { \ 101 mEnv->Release ## NAME ## ArrayElements(mJavaArray, mRawArray, 0); \ 102 } \ 103 } \ 104 void reset(PRIMITIVE_TYPE ## Array javaArray) { \ 105 mJavaArray = javaArray; \ 106 mRawArray = mEnv->Get ## NAME ## ArrayElements(mJavaArray, NULL); \ 107 } \ 108 const PRIMITIVE_TYPE* get() const { return mRawArray; } \ 109 PRIMITIVE_TYPE ## Array getJavaArray() const { return mJavaArray; } \ 110 const PRIMITIVE_TYPE& operator[](size_t n) const { return mRawArray[n]; } \ 111 PRIMITIVE_TYPE* get() { return mRawArray; } \ 112 PRIMITIVE_TYPE& operator[](size_t n) { return mRawArray[n]; } \ 113 size_t size() const { return mEnv->GetArrayLength(mJavaArray); } \ 114 private: \ 115 JNIEnv* const mEnv; \ 116 PRIMITIVE_TYPE ## Array mJavaArray; \ 117 PRIMITIVE_TYPE* mRawArray; \ 118 DISALLOW_COPY_AND_ASSIGN(Scoped ## NAME ## ArrayRW); \ 119 } 120 121 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RW(jboolean, Boolean); 122 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RW(jbyte, Byte); 123 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RW(jchar, Char); 124 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RW(jdouble, Double); 125 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RW(jfloat, Float); 126 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RW(jint, Int); 127 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RW(jlong, Long); 128 INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RW(jshort, Short); 129 130 #undef INSTANTIATE_SCOPED_PRIMITIVE_ARRAY_RW 131 132 #endif // SCOPED_PRIMITIVE_ARRAY_H_included 133