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 14 ScopedJavaLocalRef<jbyteArray> ToJavaByteArray( 15 JNIEnv* env, const uint8* bytes, size_t len) { 16 jbyteArray byte_array = env->NewByteArray(len); 17 CheckException(env); 18 DCHECK(byte_array); 19 20 jbyte* elements = env->GetByteArrayElements(byte_array, NULL); 21 memcpy(elements, bytes, len); 22 env->ReleaseByteArrayElements(byte_array, elements, 0); 23 CheckException(env); 24 25 return ScopedJavaLocalRef<jbyteArray>(env, byte_array); 26 } 27 28 ScopedJavaLocalRef<jintArray> ToJavaIntArray( 29 JNIEnv* env, const int* ints, size_t len) { 30 jintArray int_array = env->NewIntArray(len); 31 CheckException(env); 32 DCHECK(int_array); 33 34 jint* elements = env->GetIntArrayElements(int_array, NULL); 35 memcpy(elements, ints, len * sizeof(*ints)); 36 env->ReleaseIntArrayElements(int_array, elements, 0); 37 CheckException(env); 38 39 return ScopedJavaLocalRef<jintArray>(env, int_array); 40 } 41 42 ScopedJavaLocalRef<jintArray> ToJavaIntArray( 43 JNIEnv* env, const std::vector<int>& ints) { 44 return ToJavaIntArray(env, ints.begin(), ints.size()); 45 } 46 47 ScopedJavaLocalRef<jlongArray> ToJavaLongArray( 48 JNIEnv* env, const int64* longs, size_t len) { 49 jlongArray long_array = env->NewLongArray(len); 50 CheckException(env); 51 DCHECK(long_array); 52 53 jlong* elements = env->GetLongArrayElements(long_array, NULL); 54 memcpy(elements, longs, len * sizeof(*longs)); 55 env->ReleaseLongArrayElements(long_array, elements, 0); 56 CheckException(env); 57 58 return ScopedJavaLocalRef<jlongArray>(env, long_array); 59 } 60 61 // Returns a new Java long array converted from the given int64 array. 62 BASE_EXPORT ScopedJavaLocalRef<jlongArray> ToJavaLongArray( 63 JNIEnv* env, const std::vector<int64>& longs) { 64 return ToJavaLongArray(env, longs.begin(), longs.size()); 65 } 66 67 ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray( 68 JNIEnv* env, const std::vector<std::string>& v) { 69 ScopedJavaLocalRef<jclass> byte_array_clazz = GetClass(env, "[B"); 70 jobjectArray joa = env->NewObjectArray(v.size(), 71 byte_array_clazz.obj(), NULL); 72 CheckException(env); 73 74 for (size_t i = 0; i < v.size(); ++i) { 75 ScopedJavaLocalRef<jbyteArray> byte_array = ToJavaByteArray(env, 76 reinterpret_cast<const uint8*>(v[i].data()), v[i].length()); 77 env->SetObjectArrayElement(joa, i, byte_array.obj()); 78 } 79 return ScopedJavaLocalRef<jobjectArray>(env, joa); 80 } 81 82 ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStrings( 83 JNIEnv* env, const std::vector<std::string>& v) { 84 ScopedJavaLocalRef<jclass> string_clazz = GetClass(env, "java/lang/String"); 85 jobjectArray joa = env->NewObjectArray(v.size(), string_clazz.obj(), NULL); 86 CheckException(env); 87 88 for (size_t i = 0; i < v.size(); ++i) { 89 ScopedJavaLocalRef<jstring> item = ConvertUTF8ToJavaString(env, v[i]); 90 env->SetObjectArrayElement(joa, i, item.obj()); 91 } 92 return ScopedJavaLocalRef<jobjectArray>(env, joa); 93 } 94 95 ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStrings( 96 JNIEnv* env, const std::vector<string16>& v) { 97 ScopedJavaLocalRef<jclass> string_clazz = GetClass(env, "java/lang/String"); 98 jobjectArray joa = env->NewObjectArray(v.size(), string_clazz.obj(), NULL); 99 CheckException(env); 100 101 for (size_t i = 0; i < v.size(); ++i) { 102 ScopedJavaLocalRef<jstring> item = ConvertUTF16ToJavaString(env, v[i]); 103 env->SetObjectArrayElement(joa, i, item.obj()); 104 } 105 return ScopedJavaLocalRef<jobjectArray>(env, joa); 106 } 107 108 void AppendJavaStringArrayToStringVector(JNIEnv* env, 109 jobjectArray array, 110 std::vector<string16>* out) { 111 DCHECK(out); 112 if (!array) 113 return; 114 jsize len = env->GetArrayLength(array); 115 size_t back = out->size(); 116 out->resize(back + len); 117 for (jsize i = 0; i < len; ++i) { 118 ScopedJavaLocalRef<jstring> str(env, 119 static_cast<jstring>(env->GetObjectArrayElement(array, i))); 120 ConvertJavaStringToUTF16(env, str.obj(), &((*out)[back + i])); 121 } 122 } 123 124 void AppendJavaStringArrayToStringVector(JNIEnv* env, 125 jobjectArray array, 126 std::vector<std::string>* out) { 127 DCHECK(out); 128 if (!array) 129 return; 130 jsize len = env->GetArrayLength(array); 131 size_t back = out->size(); 132 out->resize(back + len); 133 for (jsize i = 0; i < len; ++i) { 134 ScopedJavaLocalRef<jstring> str(env, 135 static_cast<jstring>(env->GetObjectArrayElement(array, i))); 136 ConvertJavaStringToUTF8(env, str.obj(), &((*out)[back + i])); 137 } 138 } 139 140 void AppendJavaByteArrayToByteVector(JNIEnv* env, 141 jbyteArray byte_array, 142 std::vector<uint8>* out) { 143 DCHECK(out); 144 if (!byte_array) 145 return; 146 jsize len = env->GetArrayLength(byte_array); 147 jbyte* bytes = env->GetByteArrayElements(byte_array, NULL); 148 out->insert(out->end(), bytes, bytes + len); 149 env->ReleaseByteArrayElements(byte_array, bytes, JNI_ABORT); 150 } 151 152 void JavaByteArrayToByteVector(JNIEnv* env, 153 jbyteArray byte_array, 154 std::vector<uint8>* out) { 155 DCHECK(out); 156 out->clear(); 157 AppendJavaByteArrayToByteVector(env, byte_array, out); 158 } 159 160 void JavaIntArrayToIntVector(JNIEnv* env, 161 jintArray int_array, 162 std::vector<int>* out) { 163 DCHECK(out); 164 out->clear(); 165 jsize len = env->GetArrayLength(int_array); 166 jint* ints = env->GetIntArrayElements(int_array, NULL); 167 for (jsize i = 0; i < len; ++i) { 168 out->push_back(static_cast<int>(ints[i])); 169 } 170 env->ReleaseIntArrayElements(int_array, ints, JNI_ABORT); 171 } 172 173 void JavaFloatArrayToFloatVector(JNIEnv* env, 174 jfloatArray float_array, 175 std::vector<float>* out) { 176 DCHECK(out); 177 out->clear(); 178 jsize len = env->GetArrayLength(float_array); 179 jfloat* floats = env->GetFloatArrayElements(float_array, NULL); 180 for (jsize i = 0; i < len; ++i) { 181 out->push_back(static_cast<float>(floats[i])); 182 } 183 env->ReleaseFloatArrayElements(float_array, floats, JNI_ABORT); 184 } 185 186 void JavaArrayOfByteArrayToStringVector( 187 JNIEnv* env, 188 jobjectArray array, 189 std::vector<std::string>* out) { 190 DCHECK(out); 191 out->clear(); 192 jsize len = env->GetArrayLength(array); 193 out->resize(len); 194 for (jsize i = 0; i < len; ++i) { 195 jbyteArray bytes_array = static_cast<jbyteArray>( 196 env->GetObjectArrayElement(array, i)); 197 jsize bytes_len = env->GetArrayLength(bytes_array); 198 jbyte* bytes = env->GetByteArrayElements(bytes_array, NULL); 199 (*out)[i].assign(reinterpret_cast<const char*>(bytes), bytes_len); 200 env->ReleaseByteArrayElements(bytes_array, bytes, JNI_ABORT); 201 } 202 } 203 204 } // namespace android 205 } // namespace base 206
