base/android/jni_array.cc

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