base/android/jni_array.cc

   1 // Copyright 2012 The Chromium Authors
   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/check_op.h"
  10 #include "base/numerics/safe_conversions.h"
  11
  12 namespace base::android {
  13
  14 ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(JNIEnv* env,
  15                                                const uint8_t* bytes,
  16                                                size_t len) {
  17   const jsize len_jsize = checked_cast<jsize>(len);
  18   jbyteArray byte_array = env->NewByteArray(len_jsize);
  19   CheckException(env);
  20   DCHECK(byte_array);
  21
  22   env->SetByteArrayRegion(byte_array, 0, len_jsize,
  23                           reinterpret_cast<const jbyte*>(bytes));
  24   CheckException(env);
  25
  26   return ScopedJavaLocalRef<jbyteArray>(env, byte_array);
  27 }
  28
  29 ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(
  30     JNIEnv* env,
  31     base::span<const uint8_t> bytes) {
  32   return ToJavaByteArray(env, bytes.data(), bytes.size());
  33 }
  34
  35 ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(JNIEnv* env,
  36                                                const std::string& str) {
  37   return ToJavaByteArray(env, reinterpret_cast<const uint8_t*>(str.data()),
  38                          str.size());
  39 }
  40
  41 ScopedJavaLocalRef<jbooleanArray> ToJavaBooleanArray(JNIEnv* env,
  42                                                      const bool* bools,
  43                                                      size_t len) {
  44   const jsize len_jsize = checked_cast<jsize>(len);
  45   jbooleanArray boolean_array = env->NewBooleanArray(len_jsize);
  46   CheckException(env);
  47   DCHECK(boolean_array);
  48
  49   env->SetBooleanArrayRegion(boolean_array, 0, len_jsize,
  50                              reinterpret_cast<const jboolean*>(bools));
  51   CheckException(env);
  52
  53   return ScopedJavaLocalRef<jbooleanArray>(env, boolean_array);
  54 }
  55
  56 ScopedJavaLocalRef<jintArray> ToJavaIntArray(JNIEnv* env,
  57                                              const int* ints,
  58                                              size_t len) {
  59   const jsize len_jsize = checked_cast<jsize>(len);
  60   jintArray int_array = env->NewIntArray(len_jsize);
  61   CheckException(env);
  62   DCHECK(int_array);
  63
  64   env->SetIntArrayRegion(int_array, 0, len_jsize,
  65                          reinterpret_cast<const jint*>(ints));
  66   CheckException(env);
  67
  68   return ScopedJavaLocalRef<jintArray>(env, int_array);
  69 }
  70
  71 ScopedJavaLocalRef<jintArray> ToJavaIntArray(JNIEnv* env,
  72                                              base::span<const int> ints) {
  73   return ToJavaIntArray(env, ints.data(), ints.size());
  74 }
  75
  76 ScopedJavaLocalRef<jlongArray> ToJavaLongArray(JNIEnv* env,
  77                                                const int64_t* longs,
  78                                                size_t len) {
  79   const jsize len_jsize = checked_cast<jsize>(len);
  80   jlongArray long_array = env->NewLongArray(len_jsize);
  81   CheckException(env);
  82   DCHECK(long_array);
  83
  84   env->SetLongArrayRegion(long_array, 0, len_jsize,
  85                           reinterpret_cast<const jlong*>(longs));
  86   CheckException(env);
  87
  88   return ScopedJavaLocalRef<jlongArray>(env, long_array);
  89 }
  90
  91 // Returns a new Java long array converted from the given int64_t array.
  92 BASE_EXPORT ScopedJavaLocalRef<jlongArray> ToJavaLongArray(
  93     JNIEnv* env,
  94     base::span<const int64_t> longs) {
  95   return ToJavaLongArray(env, longs.data(), longs.size());
  96 }
  97
  98 // Returns a new Java float array converted from the given C++ float array.
  99 BASE_EXPORT ScopedJavaLocalRef<jfloatArray>
 100 ToJavaFloatArray(JNIEnv* env, const float* floats, size_t len) {
 101   const jsize len_jsize = checked_cast<jsize>(len);
 102   jfloatArray float_array = env->NewFloatArray(len_jsize);
 103   CheckException(env);
 104   DCHECK(float_array);
 105
 106   env->SetFloatArrayRegion(float_array, 0, len_jsize,
 107                            reinterpret_cast<const jfloat*>(floats));
 108   CheckException(env);
 109
 110   return ScopedJavaLocalRef<jfloatArray>(env, float_array);
 111 }
 112
 113 BASE_EXPORT ScopedJavaLocalRef<jfloatArray> ToJavaFloatArray(
 114     JNIEnv* env,
 115     base::span<const float> floats) {
 116   return ToJavaFloatArray(env, floats.data(), floats.size());
 117 }
 118
 119 BASE_EXPORT ScopedJavaLocalRef<jdoubleArray>
 120 ToJavaDoubleArray(JNIEnv* env, const double* doubles, size_t len) {
 121   const jsize len_jsize = checked_cast<jsize>(len);
 122   jdoubleArray double_array = env->NewDoubleArray(len_jsize);
 123   CheckException(env);
 124   DCHECK(double_array);
 125
 126   env->SetDoubleArrayRegion(double_array, 0, len_jsize,
 127                             reinterpret_cast<const jdouble*>(doubles));
 128   CheckException(env);
 129
 130   return ScopedJavaLocalRef<jdoubleArray>(env, double_array);
 131 }
 132
 133 BASE_EXPORT ScopedJavaLocalRef<jdoubleArray> ToJavaDoubleArray(
 134     JNIEnv* env,
 135     base::span<const double> doubles) {
 136   return ToJavaDoubleArray(env, doubles.data(), doubles.size());
 137 }
 138
 139 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfObjects(
 140     JNIEnv* env,
 141     ScopedJavaLocalRef<jclass> clazz,
 142     base::span<const ScopedJavaLocalRef<jobject>> v) {
 143   jobjectArray joa =
 144       env->NewObjectArray(checked_cast<jsize>(v.size()), clazz.obj(), nullptr);
 145   CheckException(env);
 146
 147   for (size_t i = 0; i < v.size(); ++i) {
 148     env->SetObjectArrayElement(joa, static_cast<jsize>(i), v[i].obj());
 149   }
 150   return ScopedJavaLocalRef<jobjectArray>(env, joa);
 151 }
 152
 153 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfObjects(
 154     JNIEnv* env,
 155     base::span<const ScopedJavaLocalRef<jobject>> v) {
 156   return ToJavaArrayOfObjects(env, GetClass(env, "java/lang/Object"), v);
 157 }
 158
 159 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfObjects(
 160     JNIEnv* env,
 161     base::span<const ScopedJavaGlobalRef<jobject>> v) {
 162   ScopedJavaLocalRef<jclass> object_array_clazz =
 163       GetClass(env, "java/lang/Object");
 164   jobjectArray joa = env->NewObjectArray(checked_cast<jsize>(v.size()),
 165                                          object_array_clazz.obj(), nullptr);
 166   CheckException(env);
 167
 168   for (size_t i = 0; i < v.size(); ++i) {
 169     env->SetObjectArrayElement(joa, static_cast<jsize>(i), v[i].obj());
 170   }
 171   return ScopedJavaLocalRef<jobjectArray>(env, joa);
 172 }
 173
 174 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToTypedJavaArrayOfObjects(
 175     JNIEnv* env,
 176     base::span<const ScopedJavaLocalRef<jobject>> v,
 177     const JavaRef<jclass>& type) {
 178   jobjectArray joa =
 179       env->NewObjectArray(checked_cast<jsize>(v.size()), type.obj(), nullptr);
 180   CheckException(env);
 181
 182   for (size_t i = 0; i < v.size(); ++i) {
 183     env->SetObjectArrayElement(joa, static_cast<jsize>(i), v[i].obj());
 184   }
 185   return ScopedJavaLocalRef<jobjectArray>(env, joa);
 186 }
 187
 188 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToTypedJavaArrayOfObjects(
 189     JNIEnv* env,
 190     base::span<const ScopedJavaGlobalRef<jobject>> v,
 191     const JavaRef<jclass>& type) {
 192   jobjectArray joa =
 193       env->NewObjectArray(checked_cast<jsize>(v.size()), type.obj(), nullptr);
 194   CheckException(env);
 195
 196   for (size_t i = 0; i < v.size(); ++i) {
 197     env->SetObjectArrayElement(joa, static_cast<jsize>(i), v[i].obj());
 198   }
 199   return ScopedJavaLocalRef<jobjectArray>(env, joa);
 200 }
 201
 202 ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray(
 203     JNIEnv* env,
 204     base::span<const std::string> v) {
 205   ScopedJavaLocalRef<jclass> byte_array_clazz = GetClass(env, "[B");
 206   jobjectArray joa = env->NewObjectArray(checked_cast<jsize>(v.size()),
 207                                          byte_array_clazz.obj(), nullptr);
 208   CheckException(env);
 209
 210   for (size_t i = 0; i < v.size(); ++i) {
 211     ScopedJavaLocalRef<jbyteArray> byte_array = ToJavaByteArray(
 212         env, reinterpret_cast<const uint8_t*>(v[i].data()), v[i].length());
 213     env->SetObjectArrayElement(joa, static_cast<jsize>(i), byte_array.obj());
 214   }
 215   return ScopedJavaLocalRef<jobjectArray>(env, joa);
 216 }
 217
 218 ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray(
 219     JNIEnv* env,
 220     base::span<const std::vector<uint8_t>> v) {
 221   ScopedJavaLocalRef<jclass> byte_array_clazz = GetClass(env, "[B");
 222   jobjectArray joa = env->NewObjectArray(checked_cast<jsize>(v.size()),
 223                                          byte_array_clazz.obj(), nullptr);
 224   CheckException(env);
 225
 226   for (size_t i = 0; i < v.size(); ++i) {
 227     ScopedJavaLocalRef<jbyteArray> byte_array =
 228         ToJavaByteArray(env, v[i].data(), v[i].size());
 229     env->SetObjectArrayElement(joa, static_cast<jsize>(i), byte_array.obj());
 230   }
 231   return ScopedJavaLocalRef<jobjectArray>(env, joa);
 232 }
 233
 234 ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStrings(
 235     JNIEnv* env,
 236     base::span<const std::string> v) {
 237   ScopedJavaLocalRef<jclass> string_clazz = GetClass(env, "java/lang/String");
 238   jobjectArray joa = env->NewObjectArray(checked_cast<jsize>(v.size()),
 239                                          string_clazz.obj(), nullptr);
 240   CheckException(env);
 241
 242   for (size_t i = 0; i < v.size(); ++i) {
 243     ScopedJavaLocalRef<jstring> item = ConvertUTF8ToJavaString(env, v[i]);
 244     env->SetObjectArrayElement(joa, static_cast<jsize>(i), item.obj());
 245   }
 246   return ScopedJavaLocalRef<jobjectArray>(env, joa);
 247 }
 248
 249 ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStringArray(
 250     JNIEnv* env,
 251     base::span<const std::vector<std::string>> vec_outer) {
 252   ScopedJavaLocalRef<jclass> string_array_clazz =
 253       GetClass(env, "[Ljava/lang/String;");
 254
 255   jobjectArray joa = env->NewObjectArray(checked_cast<jsize>(vec_outer.size()),
 256                                          string_array_clazz.obj(), nullptr);
 257   CheckException(env);
 258
 259   for (size_t i = 0; i < vec_outer.size(); ++i) {
 260     ScopedJavaLocalRef<jobjectArray> inner =
 261         ToJavaArrayOfStrings(env, vec_outer[i]);
 262     env->SetObjectArrayElement(joa, static_cast<jsize>(i), inner.obj());
 263   }
 264
 265   return ScopedJavaLocalRef<jobjectArray>(env, joa);
 266 }
 267
 268 ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStringArray(
 269     JNIEnv* env,
 270     base::span<const std::vector<std::u16string>> vec_outer) {
 271   ScopedJavaLocalRef<jclass> string_array_clazz =
 272       GetClass(env, "[Ljava/lang/String;");
 273
 274   jobjectArray joa = env->NewObjectArray(checked_cast<jsize>(vec_outer.size()),
 275                                          string_array_clazz.obj(), nullptr);
 276   CheckException(env);
 277
 278   for (size_t i = 0; i < vec_outer.size(); ++i) {
 279     ScopedJavaLocalRef<jobjectArray> inner =
 280         ToJavaArrayOfStrings(env, vec_outer[i]);
 281     env->SetObjectArrayElement(joa, static_cast<jsize>(i), inner.obj());
 282   }
 283
 284   return ScopedJavaLocalRef<jobjectArray>(env, joa);
 285 }
 286
 287 ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStrings(
 288     JNIEnv* env,
 289     base::span<const std::u16string> v) {
 290   ScopedJavaLocalRef<jclass> string_clazz = GetClass(env, "java/lang/String");
 291   jobjectArray joa = env->NewObjectArray(checked_cast<jsize>(v.size()),
 292                                          string_clazz.obj(), nullptr);
 293   CheckException(env);
 294
 295   for (size_t i = 0; i < v.size(); ++i) {
 296     ScopedJavaLocalRef<jstring> item = ConvertUTF16ToJavaString(env, v[i]);
 297     env->SetObjectArrayElement(joa, static_cast<jsize>(i), item.obj());
 298   }
 299   return ScopedJavaLocalRef<jobjectArray>(env, joa);
 300 }
 301
 302 void AppendJavaStringArrayToStringVector(JNIEnv* env,
 303                                          const JavaRef<jobjectArray>& array,
 304                                          std::vector<std::u16string>* out) {
 305   DCHECK(out);
 306   if (!array)
 307     return;
 308   size_t len = SafeGetArrayLength(env, array);
 309   size_t back = out->size();
 310   out->resize(back + len);
 311   for (size_t i = 0; i < len; ++i) {
 312     ScopedJavaLocalRef<jstring> str(
 313         env, static_cast<jstring>(env->GetObjectArrayElement(
 314                  array.obj(), static_cast<jsize>(i))));
 315     ConvertJavaStringToUTF16(env, str.obj(), out->data() + back + i);
 316   }
 317 }
 318
 319 void AppendJavaStringArrayToStringVector(JNIEnv* env,
 320                                          const JavaRef<jobjectArray>& array,
 321                                          std::vector<std::string>* out) {
 322   DCHECK(out);
 323   if (!array)
 324     return;
 325   size_t len = SafeGetArrayLength(env, array);
 326   size_t back = out->size();
 327   out->resize(back + len);
 328   for (size_t i = 0; i < len; ++i) {
 329     ScopedJavaLocalRef<jstring> str(
 330         env, static_cast<jstring>(env->GetObjectArrayElement(
 331                  array.obj(), static_cast<jsize>(i))));
 332     ConvertJavaStringToUTF8(env, str.obj(), out->data() + back + i);
 333   }
 334 }
 335
 336 void AppendJavaByteArrayToByteVector(JNIEnv* env,
 337                                      const JavaRef<jbyteArray>& byte_array,
 338                                      std::vector<uint8_t>* out) {
 339   DCHECK(out);
 340   if (!byte_array)
 341     return;
 342   size_t len = SafeGetArrayLength(env, byte_array);
 343   if (!len)
 344     return;
 345   size_t back = out->size();
 346   out->resize(back + len);
 347   env->GetByteArrayRegion(byte_array.obj(), 0, static_cast<jsize>(len),
 348                           reinterpret_cast<int8_t*>(out->data() + back));
 349 }
 350
 351 void JavaByteArrayToByteVector(JNIEnv* env,
 352                                const JavaRef<jbyteArray>& byte_array,
 353                                std::vector<uint8_t>* out) {
 354   DCHECK(out);
 355   DCHECK(byte_array);
 356   out->clear();
 357   AppendJavaByteArrayToByteVector(env, byte_array, out);
 358 }
 359
 360 size_t JavaByteArrayToByteSpan(JNIEnv* env,
 361                                const JavaRef<jbyteArray>& byte_array,
 362                                base::span<uint8_t> dest) {
 363   CHECK(byte_array);
 364   size_t len = SafeGetArrayLength(env, byte_array);
 365   size_t span_len = dest.size_bytes();
 366   CHECK_GE(span_len, len) << "Target span is too small, java array size: "
 367                           << len << ", span size: " << span_len;
 368   env->GetByteArrayRegion(byte_array.obj(), 0, static_cast<jsize>(len),
 369                           reinterpret_cast<int8_t*>(dest.data()));
 370   return len;
 371 }
 372
 373 void JavaByteArrayToString(JNIEnv* env,
 374                            const JavaRef<jbyteArray>& byte_array,
 375                            std::string* out) {
 376   DCHECK(out);
 377   DCHECK(byte_array);
 378
 379   std::vector<uint8_t> byte_vector;
 380   JavaByteArrayToByteVector(env, byte_array, &byte_vector);
 381   out->assign(byte_vector.begin(), byte_vector.end());
 382 }
 383
 384 void JavaBooleanArrayToBoolVector(JNIEnv* env,
 385                                   const JavaRef<jbooleanArray>& boolean_array,
 386                                   std::vector<bool>* out) {
 387   DCHECK(out);
 388   if (!boolean_array)
 389     return;
 390   size_t len = SafeGetArrayLength(env, boolean_array);
 391   if (!len)
 392     return;
 393   out->resize(len);
 394   // It is not possible to get bool* out of vector<bool>.
 395   jboolean* values = env->GetBooleanArrayElements(boolean_array.obj(), nullptr);
 396   for (size_t i = 0; i < len; ++i) {
 397     out->at(i) = static_cast<bool>(values[i]);
 398   }
 399   env->ReleaseBooleanArrayElements(boolean_array.obj(), values, JNI_ABORT);
 400 }
 401
 402 void JavaIntArrayToIntVector(JNIEnv* env,
 403                              const JavaRef<jintArray>& int_array,
 404                              std::vector<int>* out) {
 405   DCHECK(out);
 406   size_t len = SafeGetArrayLength(env, int_array);
 407   out->resize(len);
 408   if (!len)
 409     return;
 410   env->GetIntArrayRegion(int_array.obj(), 0, static_cast<jsize>(len),
 411                          out->data());
 412 }
 413
 414 void JavaLongArrayToInt64Vector(JNIEnv* env,
 415                                 const JavaRef<jlongArray>& long_array,
 416                                 std::vector<int64_t>* out) {
 417   DCHECK(out);
 418   std::vector<jlong> temp;
 419   JavaLongArrayToLongVector(env, long_array, &temp);
 420   out->resize(0);
 421   out->insert(out->begin(), temp.begin(), temp.end());
 422 }
 423
 424 void JavaLongArrayToLongVector(JNIEnv* env,
 425                                const JavaRef<jlongArray>& long_array,
 426                                std::vector<jlong>* out) {
 427   DCHECK(out);
 428   size_t len = SafeGetArrayLength(env, long_array);
 429   out->resize(len);
 430   if (!len)
 431     return;
 432   env->GetLongArrayRegion(long_array.obj(), 0, static_cast<jsize>(len),
 433                           out->data());
 434 }
 435
 436 void JavaFloatArrayToFloatVector(JNIEnv* env,
 437                                  const JavaRef<jfloatArray>& float_array,
 438                                  std::vector<float>* out) {
 439   DCHECK(out);
 440   size_t len = SafeGetArrayLength(env, float_array);
 441   out->resize(len);
 442   if (!len)
 443     return;
 444   env->GetFloatArrayRegion(float_array.obj(), 0, static_cast<jsize>(len),
 445                            out->data());
 446 }
 447
 448 void JavaDoubleArrayToDoubleVector(JNIEnv* env,
 449                                    const JavaRef<jdoubleArray>& double_array,
 450                                    std::vector<double>* out) {
 451   DCHECK(out);
 452   size_t len = SafeGetArrayLength(env, double_array);
 453   out->resize(len);
 454   if (!len)
 455     return;
 456   env->GetDoubleArrayRegion(double_array.obj(), 0, static_cast<jsize>(len),
 457                             out->data());
 458 }
 459
 460 void JavaArrayOfByteArrayToStringVector(JNIEnv* env,
 461                                         const JavaRef<jobjectArray>& array,
 462                                         std::vector<std::string>* out) {
 463   DCHECK(out);
 464   size_t len = SafeGetArrayLength(env, array);
 465   out->resize(len);
 466   for (size_t i = 0; i < len; ++i) {
 467     ScopedJavaLocalRef<jbyteArray> bytes_array(
 468         env, static_cast<jbyteArray>(env->GetObjectArrayElement(
 469                  array.obj(), static_cast<jsize>(i))));
 470     size_t bytes_len = SafeGetArrayLength(env, bytes_array);
 471     jbyte* bytes = env->GetByteArrayElements(bytes_array.obj(), nullptr);
 472     (*out)[i].assign(reinterpret_cast<const char*>(bytes), bytes_len);
 473     env->ReleaseByteArrayElements(bytes_array.obj(), bytes, JNI_ABORT);
 474   }
 475 }
 476
 477 void JavaArrayOfByteArrayToBytesVector(JNIEnv* env,
 478                                        const JavaRef<jobjectArray>& array,
 479                                        std::vector<std::vector<uint8_t>>* out) {
 480   DCHECK(out);
 481   const size_t len = SafeGetArrayLength(env, array);
 482   out->resize(len);
 483   for (size_t i = 0; i < len; ++i) {
 484     ScopedJavaLocalRef<jbyteArray> bytes_array(
 485         env, static_cast<jbyteArray>(env->GetObjectArrayElement(
 486                  array.obj(), static_cast<jsize>(i))));
 487     JavaByteArrayToByteVector(env, bytes_array, &(*out)[i]);
 488   }
 489 }
 490
 491 void Java2dStringArrayTo2dStringVector(
 492     JNIEnv* env,
 493     const JavaRef<jobjectArray>& array,
 494     std::vector<std::vector<std::u16string>>* out) {
 495   DCHECK(out);
 496   size_t len = SafeGetArrayLength(env, array);
 497   out->resize(len);
 498   for (size_t i = 0; i < len; ++i) {
 499     ScopedJavaLocalRef<jobjectArray> strings_array(
 500         env, static_cast<jobjectArray>(env->GetObjectArrayElement(
 501                  array.obj(), static_cast<jsize>(i))));
 502
 503     out->at(i).clear();
 504     AppendJavaStringArrayToStringVector(env, strings_array, &out->at(i));
 505   }
 506 }
 507
 508 void Java2dStringArrayTo2dStringVector(
 509     JNIEnv* env,
 510     const JavaRef<jobjectArray>& array,
 511     std::vector<std::vector<std::string>>* out) {
 512   DCHECK(out);
 513   size_t len = SafeGetArrayLength(env, array);
 514   out->resize(len);
 515   for (size_t i = 0; i < len; ++i) {
 516     ScopedJavaLocalRef<jobjectArray> strings_array(
 517         env, static_cast<jobjectArray>(env->GetObjectArrayElement(
 518                  array.obj(), static_cast<jsize>(i))));
 519
 520     out->at(i).clear();
 521     AppendJavaStringArrayToStringVector(env, strings_array, &out->at(i));
 522   }
 523 }
 524
 525 void JavaArrayOfIntArrayToIntVector(JNIEnv* env,
 526                                     const JavaRef<jobjectArray>& array,
 527                                     std::vector<std::vector<int>>* out) {
 528   DCHECK(out);
 529   size_t len = SafeGetArrayLength(env, array);
 530   out->resize(len);
 531   for (size_t i = 0; i < len; ++i) {
 532     ScopedJavaLocalRef<jintArray> int_array(
 533         env, static_cast<jintArray>(env->GetObjectArrayElement(
 534                  array.obj(), static_cast<jsize>(i))));
 535     JavaIntArrayToIntVector(env, int_array, &out->at(i));
 536   }
 537 }
 538
 539 }  // namespace base::android