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 #ifndef BASE_ANDROID_JNI_ARRAY_H_
6 #define BASE_ANDROID_JNI_ARRAY_H_
7
8 #include <jni.h>
9 #include <stddef.h>
10 #include <stdint.h>
11
12 #include <ostream>
13 #include <string>
14 #include <vector>
15
16 #include "base/android/scoped_java_ref.h"
17 #include "base/check_op.h"
18 #include "base/compiler_specific.h"
19 #include "base/containers/span.h"
20
21 namespace base::android {
22
23 // As |GetArrayLength| makes no guarantees about the returned value (e.g., it
24 // may be -1 if |array| is not a valid Java array), provide a safe wrapper
25 // that always returns a valid, non-negative size.
26 // Returns the length of Java array.
27 template <typename JavaArrayType>
SafeGetArrayLength(JNIEnv * env,const JavaRef<JavaArrayType> & jarray)28 BASE_EXPORT size_t SafeGetArrayLength(JNIEnv* env,
29 const JavaRef<JavaArrayType>& jarray) {
30 DCHECK(jarray);
31 jsize length = env->GetArrayLength(jarray.obj());
32 DCHECK_GE(length, 0) << "Invalid array length: " << length;
33 return static_cast<size_t>(std::max(0, length));
34 }
35
36 // Returns a new Java byte array converted from the given bytes array.
37 UNSAFE_BUFFER_USAGE BASE_EXPORT ScopedJavaLocalRef<jbyteArray>
38 ToJavaByteArray(JNIEnv* env, const uint8_t* bytes, size_t len);
39
40 BASE_EXPORT ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(
41 JNIEnv* env,
42 span<const uint8_t> bytes);
43
44 // Returns a new Java byte array converted from the given string. No UTF-8
45 // conversion is performed.
46 BASE_EXPORT ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(
47 JNIEnv* env,
48 std::string_view str);
49
50 // Returns a new Java boolean array converted from the given bool array.
51 BASE_EXPORT ScopedJavaLocalRef<jbooleanArray> ToJavaBooleanArray(
52 JNIEnv* env,
53 span<const bool> bools);
54
55 // Returns a new Java boolean array converted from the given bool vector.
56 //
57 // std::vector<bool> does not convert to span, so we have a separate overload.
58 BASE_EXPORT ScopedJavaLocalRef<jbooleanArray> ToJavaBooleanArray(
59 JNIEnv* env,
60 const std::vector<bool>& bools);
61
62 // Returns a new Java int array converted from the given int array.
63 BASE_EXPORT ScopedJavaLocalRef<jintArray> ToJavaIntArray(
64 JNIEnv* env,
65 span<const int32_t> ints);
66
67 // Returns a new Java long array converted from the given int64_t array.
68 BASE_EXPORT ScopedJavaLocalRef<jlongArray> ToJavaLongArray(
69 JNIEnv* env,
70 span<const int64_t> longs);
71
72 // Returns a new Java float array converted from the given C++ float array.
73 BASE_EXPORT ScopedJavaLocalRef<jfloatArray> ToJavaFloatArray(
74 JNIEnv* env,
75 span<const float> floats);
76
77 // Returns a new Java double array converted from the given C++ double array.
78 BASE_EXPORT ScopedJavaLocalRef<jdoubleArray> ToJavaDoubleArray(
79 JNIEnv* env,
80 span<const double> doubles);
81
82 // Returns a new clazz[] with the content of |v|.
83 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfObjects(
84 JNIEnv* env,
85 jclass clazz,
86 span<const ScopedJavaLocalRef<jobject>> v);
87
88 // Returns a new Object[] with the content of |v|.
89 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfObjects(
90 JNIEnv* env,
91 span<const ScopedJavaLocalRef<jobject>> v);
92 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfObjects(
93 JNIEnv* env,
94 span<const ScopedJavaGlobalRef<jobject>> v);
95
96 // Returns a new Type[] with the content of |v|.
97 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToTypedJavaArrayOfObjects(
98 JNIEnv* env,
99 span<const ScopedJavaLocalRef<jobject>> v,
100 jclass type);
101 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToTypedJavaArrayOfObjects(
102 JNIEnv* env,
103 span<const ScopedJavaGlobalRef<jobject>> v,
104 jclass type);
105
106 // Returns a array of Java byte array converted from |v|.
107 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray(
108 JNIEnv* env,
109 span<const std::string> v);
110
111 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray(
112 JNIEnv* env,
113 span<const std::vector<uint8_t>> v);
114
115 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStrings(
116 JNIEnv* env,
117 span<const std::string> v);
118
119 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStrings(
120 JNIEnv* env,
121 span<const std::u16string> v);
122
123 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStringArray(
124 JNIEnv* env,
125 span<const std::vector<std::string>> v);
126
127 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStringArray(
128 JNIEnv* env,
129 span<const std::vector<std::u16string>> v);
130
131 // Converts a Java string array to a native array.
132 BASE_EXPORT void AppendJavaStringArrayToStringVector(
133 JNIEnv* env,
134 const JavaRef<jobjectArray>& array,
135 std::vector<std::u16string>* out);
136
137 BASE_EXPORT void AppendJavaStringArrayToStringVector(
138 JNIEnv* env,
139 const JavaRef<jobjectArray>& array,
140 std::vector<std::string>* out);
141
142 // Appends the Java bytes in |bytes_array| onto the end of |out|.
143 BASE_EXPORT void AppendJavaByteArrayToByteVector(
144 JNIEnv* env,
145 const JavaRef<jbyteArray>& byte_array,
146 std::vector<uint8_t>* out);
147
148 // Replaces the content of |out| with the Java bytes in |byte_array|.
149 BASE_EXPORT void JavaByteArrayToByteVector(
150 JNIEnv* env,
151 const JavaRef<jbyteArray>& byte_array,
152 std::vector<uint8_t>* out);
153
154 // Copy the contents of java |byte_array| into |dest|. The span must be larger
155 // than or equal to the array.
156 // Returns the number of bytes copied.
157 BASE_EXPORT size_t
158 JavaByteArrayToByteSpan(JNIEnv* env,
159 const JavaRef<jbyteArray>& byte_array,
160 span<uint8_t> dest);
161
162 // Replaces the content of |out| with the Java bytes in |byte_array|. No UTF-8
163 // conversion is performed.
164 BASE_EXPORT void JavaByteArrayToString(JNIEnv* env,
165 const JavaRef<jbyteArray>& byte_array,
166 std::string* out);
167
168 // Replaces the content of |out| with the Java booleans in |boolean_array|.
169 BASE_EXPORT void JavaBooleanArrayToBoolVector(
170 JNIEnv* env,
171 const JavaRef<jbooleanArray>& boolean_array,
172 std::vector<bool>* out);
173
174 // Replaces the content of |out| with the Java ints in |int_array|.
175 BASE_EXPORT void JavaIntArrayToIntVector(JNIEnv* env,
176 const JavaRef<jintArray>& int_array,
177 std::vector<int>* out);
178
179 // Replaces the content of |out| with the Java longs in |long_array|.
180 BASE_EXPORT void JavaLongArrayToInt64Vector(
181 JNIEnv* env,
182 const JavaRef<jlongArray>& long_array,
183 std::vector<int64_t>* out);
184
185 // Replaces the content of |out| with the Java longs in |long_array|.
186 BASE_EXPORT void JavaLongArrayToLongVector(
187 JNIEnv* env,
188 const JavaRef<jlongArray>& long_array,
189 std::vector<jlong>* out);
190
191 // Replaces the content of |out| with the Java floats in |float_array|.
192 BASE_EXPORT void JavaFloatArrayToFloatVector(
193 JNIEnv* env,
194 const JavaRef<jfloatArray>& float_array,
195 std::vector<float>* out);
196
197 // Replaces the content of |out| with the Java doubles in |double_array|.
198 BASE_EXPORT void JavaDoubleArrayToDoubleVector(
199 JNIEnv* env,
200 const JavaRef<jdoubleArray>& double_array,
201 std::vector<double>* out);
202
203 // Assuming |array| is an byte[][] (array of byte arrays), replaces the
204 // content of |out| with the corresponding vector of strings. No UTF-8
205 // conversion is performed.
206 BASE_EXPORT void JavaArrayOfByteArrayToStringVector(
207 JNIEnv* env,
208 const JavaRef<jobjectArray>& array,
209 std::vector<std::string>* out);
210
211 // Assuming |array| is an byte[][] (array of byte arrays), replaces the
212 // content of |out| with the corresponding vector of vector of uint8. No UTF-8
213 // conversion is performed.
214 BASE_EXPORT void JavaArrayOfByteArrayToBytesVector(
215 JNIEnv* env,
216 const JavaRef<jobjectArray>& array,
217 std::vector<std::vector<uint8_t>>* out);
218
219 // Assuming |array| is an String[][] (array of String arrays), replaces the
220 // content of |out| with the corresponding vector of string vectors.
221 BASE_EXPORT void Java2dStringArrayTo2dStringVector(
222 JNIEnv* env,
223 const JavaRef<jobjectArray>& array,
224 std::vector<std::vector<std::string>>* out);
225
226 // Assuming |array| is an String[][] (array of String arrays), replaces the
227 // content of |out| with the corresponding vector of string vectors. No UTF-8
228 // conversion is performed.
229 BASE_EXPORT void Java2dStringArrayTo2dStringVector(
230 JNIEnv* env,
231 const JavaRef<jobjectArray>& array,
232 std::vector<std::vector<std::u16string>>* out);
233
234 // Assuming |array| is an int[][] (array of int arrays), replaces the
235 // contents of |out| with the corresponding vectors of ints.
236 BASE_EXPORT void JavaArrayOfIntArrayToIntVector(
237 JNIEnv* env,
238 const JavaRef<jobjectArray>& array,
239 std::vector<std::vector<int>>* out);
240
241 } // namespace base::android
242
243 #endif // BASE_ANDROID_JNI_ARRAY_H_
244