| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/android/jni_array.h" | |
| 6 | |
| 7 #include "base/android/jni_android.h" | |
| 8 #include "base/android/jni_string.h" | |
| 9 #include "base/logging.h" | |
| 10 | |
| 11 namespace base { | |
| 12 namespace android { | |
| 13 namespace { | |
| 14 | |
| 15 // As |GetArrayLength| makes no guarantees about the returned value (e.g., it | |
| 16 // may be -1 if |array| is not a valid Java array), provide a safe wrapper | |
| 17 // that always returns a valid, non-negative size. | |
| 18 template <typename JavaArrayType> | |
| 19 size_t SafeGetArrayLength(JNIEnv* env, JavaArrayType jarray) { | |
| 20 DCHECK(jarray); | |
| 21 jsize length = env->GetArrayLength(jarray); | |
| 22 DCHECK_GE(length, 0) << "Invalid array length: " << length; | |
| 23 return static_cast<size_t>(std::max(0, length)); | |
| 24 } | |
| 25 | |
| 26 } // namespace | |
| 27 | |
| 28 ScopedJavaLocalRef<jbyteArray> ToJavaByteArray( | |
| 29 JNIEnv* env, const uint8* bytes, size_t len) { | |
| 30 jbyteArray byte_array = env->NewByteArray(len); | |
| 31 CheckException(env); | |
| 32 DCHECK(byte_array); | |
| 33 | |
| 34 env->SetByteArrayRegion( | |
| 35 byte_array, 0, len, reinterpret_cast<const jbyte*>(bytes)); | |
| 36 CheckException(env); | |
| 37 | |
| 38 return ScopedJavaLocalRef<jbyteArray>(env, byte_array); | |
| 39 } | |
| 40 | |
| 41 ScopedJavaLocalRef<jintArray> ToJavaIntArray( | |
| 42 JNIEnv* env, const int* ints, size_t len) { | |
| 43 jintArray int_array = env->NewIntArray(len); | |
| 44 CheckException(env); | |
| 45 DCHECK(int_array); | |
| 46 | |
| 47 env->SetIntArrayRegion( | |
| 48 int_array, 0, len, reinterpret_cast<const jint*>(ints)); | |
| 49 CheckException(env); | |
| 50 | |
| 51 return ScopedJavaLocalRef<jintArray>(env, int_array); | |
| 52 } | |
| 53 | |
| 54 ScopedJavaLocalRef<jintArray> ToJavaIntArray( | |
| 55 JNIEnv* env, const std::vector<int>& ints) { | |
| 56 return ToJavaIntArray(env, ints.data(), ints.size()); | |
| 57 } | |
| 58 | |
| 59 ScopedJavaLocalRef<jlongArray> ToJavaLongArray( | |
| 60 JNIEnv* env, const int64* longs, size_t len) { | |
| 61 jlongArray long_array = env->NewLongArray(len); | |
| 62 CheckException(env); | |
| 63 DCHECK(long_array); | |
| 64 | |
| 65 env->SetLongArrayRegion( | |
| 66 long_array, 0, len, reinterpret_cast<const jlong*>(longs)); | |
| 67 CheckException(env); | |
| 68 | |
| 69 return ScopedJavaLocalRef<jlongArray>(env, long_array); | |
| 70 } | |
| 71 | |
| 72 // Returns a new Java long array converted from the given int64 array. | |
| 73 BASE_EXPORT ScopedJavaLocalRef<jlongArray> ToJavaLongArray( | |
| 74 JNIEnv* env, const std::vector<int64>& longs) { | |
| 75 return ToJavaLongArray(env, longs.data(), longs.size()); | |
| 76 } | |
| 77 | |
| 78 ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray( | |
| 79 JNIEnv* env, const std::vector<std::string>& v) { | |
| 80 ScopedJavaLocalRef<jclass> byte_array_clazz = GetClass(env, "[B"); | |
| 81 jobjectArray joa = env->NewObjectArray(v.size(), | |
| 82 byte_array_clazz.obj(), NULL); | |
| 83 CheckException(env); | |
| 84 | |
| 85 for (size_t i = 0; i < v.size(); ++i) { | |
| 86 ScopedJavaLocalRef<jbyteArray> byte_array = ToJavaByteArray(env, | |
| 87 reinterpret_cast<const uint8*>(v[i].data()), v[i].length()); | |
| 88 env->SetObjectArrayElement(joa, i, byte_array.obj()); | |
| 89 } | |
| 90 return ScopedJavaLocalRef<jobjectArray>(env, joa); | |
| 91 } | |
| 92 | |
| 93 ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStrings( | |
| 94 JNIEnv* env, const std::vector<std::string>& v) { | |
| 95 ScopedJavaLocalRef<jclass> string_clazz = GetClass(env, "java/lang/String"); | |
| 96 jobjectArray joa = env->NewObjectArray(v.size(), string_clazz.obj(), NULL); | |
| 97 CheckException(env); | |
| 98 | |
| 99 for (size_t i = 0; i < v.size(); ++i) { | |
| 100 ScopedJavaLocalRef<jstring> item = ConvertUTF8ToJavaString(env, v[i]); | |
| 101 env->SetObjectArrayElement(joa, i, item.obj()); | |
| 102 } | |
| 103 return ScopedJavaLocalRef<jobjectArray>(env, joa); | |
| 104 } | |
| 105 | |
| 106 ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStrings( | |
| 107 JNIEnv* env, const std::vector<string16>& v) { | |
| 108 ScopedJavaLocalRef<jclass> string_clazz = GetClass(env, "java/lang/String"); | |
| 109 jobjectArray joa = env->NewObjectArray(v.size(), string_clazz.obj(), NULL); | |
| 110 CheckException(env); | |
| 111 | |
| 112 for (size_t i = 0; i < v.size(); ++i) { | |
| 113 ScopedJavaLocalRef<jstring> item = ConvertUTF16ToJavaString(env, v[i]); | |
| 114 env->SetObjectArrayElement(joa, i, item.obj()); | |
| 115 } | |
| 116 return ScopedJavaLocalRef<jobjectArray>(env, joa); | |
| 117 } | |
| 118 | |
| 119 void AppendJavaStringArrayToStringVector(JNIEnv* env, | |
| 120 jobjectArray array, | |
| 121 std::vector<string16>* out) { | |
| 122 DCHECK(out); | |
| 123 if (!array) | |
| 124 return; | |
| 125 size_t len = SafeGetArrayLength(env, array); | |
| 126 size_t back = out->size(); | |
| 127 out->resize(back + len); | |
| 128 for (size_t i = 0; i < len; ++i) { | |
| 129 ScopedJavaLocalRef<jstring> str(env, | |
| 130 static_cast<jstring>(env->GetObjectArrayElement(array, i))); | |
| 131 ConvertJavaStringToUTF16(env, str.obj(), &((*out)[back + i])); | |
| 132 } | |
| 133 } | |
| 134 | |
| 135 void AppendJavaStringArrayToStringVector(JNIEnv* env, | |
| 136 jobjectArray array, | |
| 137 std::vector<std::string>* out) { | |
| 138 DCHECK(out); | |
| 139 if (!array) | |
| 140 return; | |
| 141 size_t len = SafeGetArrayLength(env, array); | |
| 142 size_t back = out->size(); | |
| 143 out->resize(back + len); | |
| 144 for (size_t i = 0; i < len; ++i) { | |
| 145 ScopedJavaLocalRef<jstring> str(env, | |
| 146 static_cast<jstring>(env->GetObjectArrayElement(array, i))); | |
| 147 ConvertJavaStringToUTF8(env, str.obj(), &((*out)[back + i])); | |
| 148 } | |
| 149 } | |
| 150 | |
| 151 void AppendJavaByteArrayToByteVector(JNIEnv* env, | |
| 152 jbyteArray byte_array, | |
| 153 std::vector<uint8>* out) { | |
| 154 DCHECK(out); | |
| 155 if (!byte_array) | |
| 156 return; | |
| 157 size_t len = SafeGetArrayLength(env, byte_array); | |
| 158 if (!len) | |
| 159 return; | |
| 160 size_t back = out->size(); | |
| 161 out->resize(back + len); | |
| 162 env->GetByteArrayRegion(byte_array, 0, len, | |
| 163 reinterpret_cast<int8*>(&(*out)[back])); | |
| 164 } | |
| 165 | |
| 166 void JavaByteArrayToByteVector(JNIEnv* env, | |
| 167 jbyteArray byte_array, | |
| 168 std::vector<uint8>* out) { | |
| 169 DCHECK(out); | |
| 170 DCHECK(byte_array); | |
| 171 out->clear(); | |
| 172 AppendJavaByteArrayToByteVector(env, byte_array, out); | |
| 173 } | |
| 174 | |
| 175 void JavaIntArrayToIntVector(JNIEnv* env, | |
| 176 jintArray int_array, | |
| 177 std::vector<int>* out) { | |
| 178 DCHECK(out); | |
| 179 size_t len = SafeGetArrayLength(env, int_array); | |
| 180 out->resize(len); | |
| 181 if (!len) | |
| 182 return; | |
| 183 // TODO(jdduke): Use |out->data()| for pointer access after switch to libc++, | |
| 184 // both here and in the other conversion routines. See crbug.com/427718. | |
| 185 env->GetIntArrayRegion(int_array, 0, len, &(*out)[0]); | |
| 186 } | |
| 187 | |
| 188 void JavaLongArrayToLongVector(JNIEnv* env, | |
| 189 jlongArray long_array, | |
| 190 std::vector<jlong>* out) { | |
| 191 DCHECK(out); | |
| 192 size_t len = SafeGetArrayLength(env, long_array); | |
| 193 out->resize(len); | |
| 194 if (!len) | |
| 195 return; | |
| 196 env->GetLongArrayRegion(long_array, 0, len, &(*out)[0]); | |
| 197 } | |
| 198 | |
| 199 void JavaFloatArrayToFloatVector(JNIEnv* env, | |
| 200 jfloatArray float_array, | |
| 201 std::vector<float>* out) { | |
| 202 DCHECK(out); | |
| 203 size_t len = SafeGetArrayLength(env, float_array); | |
| 204 out->resize(len); | |
| 205 if (!len) | |
| 206 return; | |
| 207 env->GetFloatArrayRegion(float_array, 0, len, &(*out)[0]); | |
| 208 } | |
| 209 | |
| 210 void JavaArrayOfByteArrayToStringVector( | |
| 211 JNIEnv* env, | |
| 212 jobjectArray array, | |
| 213 std::vector<std::string>* out) { | |
| 214 DCHECK(out); | |
| 215 size_t len = SafeGetArrayLength(env, array); | |
| 216 out->resize(len); | |
| 217 for (size_t i = 0; i < len; ++i) { | |
| 218 ScopedJavaLocalRef<jbyteArray> bytes_array( | |
| 219 env, static_cast<jbyteArray>( | |
| 220 env->GetObjectArrayElement(array, i))); | |
| 221 jsize bytes_len = env->GetArrayLength(bytes_array.obj()); | |
| 222 jbyte* bytes = env->GetByteArrayElements(bytes_array.obj(), NULL); | |
| 223 (*out)[i].assign(reinterpret_cast<const char*>(bytes), bytes_len); | |
| 224 env->ReleaseByteArrayElements(bytes_array.obj(), bytes, JNI_ABORT); | |
| 225 } | |
| 226 } | |
| 227 | |
| 228 } // namespace android | |
| 229 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
