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