OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/android/jni_array.h" | 5 #include "base/android/jni_array.h" |
6 | 6 |
7 #include "base/android/jni_android.h" | 7 #include "base/android/jni_android.h" |
8 #include "base/android/jni_string.h" | 8 #include "base/android/jni_string.h" |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 | 10 |
(...skipping 27 matching lines...) Expand all Loading... |
38 | 38 |
39 return ScopedJavaLocalRef<jbyteArray>(env, byte_array); | 39 return ScopedJavaLocalRef<jbyteArray>(env, byte_array); |
40 } | 40 } |
41 | 41 |
42 ScopedJavaLocalRef<jbyteArray> ToJavaByteArray( | 42 ScopedJavaLocalRef<jbyteArray> ToJavaByteArray( |
43 JNIEnv* env, | 43 JNIEnv* env, |
44 const std::vector<uint8_t>& bytes) { | 44 const std::vector<uint8_t>& bytes) { |
45 return ToJavaByteArray(env, bytes.data(), bytes.size()); | 45 return ToJavaByteArray(env, bytes.data(), bytes.size()); |
46 } | 46 } |
47 | 47 |
| 48 ScopedJavaLocalRef<jbooleanArray> ToJavaBooleanArray(JNIEnv* env, |
| 49 const bool* bools, |
| 50 size_t len) { |
| 51 jbooleanArray boolean_array = env->NewBooleanArray(len); |
| 52 CheckException(env); |
| 53 DCHECK(boolean_array); |
| 54 |
| 55 env->SetBooleanArrayRegion(boolean_array, 0, len, |
| 56 reinterpret_cast<const jboolean*>(bools)); |
| 57 CheckException(env); |
| 58 |
| 59 return ScopedJavaLocalRef<jbooleanArray>(env, boolean_array); |
| 60 } |
| 61 |
48 ScopedJavaLocalRef<jintArray> ToJavaIntArray( | 62 ScopedJavaLocalRef<jintArray> ToJavaIntArray( |
49 JNIEnv* env, const int* ints, size_t len) { | 63 JNIEnv* env, const int* ints, size_t len) { |
50 jintArray int_array = env->NewIntArray(len); | 64 jintArray int_array = env->NewIntArray(len); |
51 CheckException(env); | 65 CheckException(env); |
52 DCHECK(int_array); | 66 DCHECK(int_array); |
53 | 67 |
54 env->SetIntArrayRegion( | 68 env->SetIntArrayRegion( |
55 int_array, 0, len, reinterpret_cast<const jint*>(ints)); | 69 int_array, 0, len, reinterpret_cast<const jint*>(ints)); |
56 CheckException(env); | 70 CheckException(env); |
57 | 71 |
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
150 std::vector<string16>* out) { | 164 std::vector<string16>* out) { |
151 DCHECK(out); | 165 DCHECK(out); |
152 if (!array) | 166 if (!array) |
153 return; | 167 return; |
154 size_t len = SafeGetArrayLength(env, array); | 168 size_t len = SafeGetArrayLength(env, array); |
155 size_t back = out->size(); | 169 size_t back = out->size(); |
156 out->resize(back + len); | 170 out->resize(back + len); |
157 for (size_t i = 0; i < len; ++i) { | 171 for (size_t i = 0; i < len; ++i) { |
158 ScopedJavaLocalRef<jstring> str(env, | 172 ScopedJavaLocalRef<jstring> str(env, |
159 static_cast<jstring>(env->GetObjectArrayElement(array, i))); | 173 static_cast<jstring>(env->GetObjectArrayElement(array, i))); |
160 ConvertJavaStringToUTF16(env, str.obj(), &((*out)[back + i])); | 174 ConvertJavaStringToUTF16(env, str.obj(), out->data() + back + i); |
161 } | 175 } |
162 } | 176 } |
163 | 177 |
164 void AppendJavaStringArrayToStringVector(JNIEnv* env, | 178 void AppendJavaStringArrayToStringVector(JNIEnv* env, |
165 jobjectArray array, | 179 jobjectArray array, |
166 std::vector<std::string>* out) { | 180 std::vector<std::string>* out) { |
167 DCHECK(out); | 181 DCHECK(out); |
168 if (!array) | 182 if (!array) |
169 return; | 183 return; |
170 size_t len = SafeGetArrayLength(env, array); | 184 size_t len = SafeGetArrayLength(env, array); |
171 size_t back = out->size(); | 185 size_t back = out->size(); |
172 out->resize(back + len); | 186 out->resize(back + len); |
173 for (size_t i = 0; i < len; ++i) { | 187 for (size_t i = 0; i < len; ++i) { |
174 ScopedJavaLocalRef<jstring> str(env, | 188 ScopedJavaLocalRef<jstring> str(env, |
175 static_cast<jstring>(env->GetObjectArrayElement(array, i))); | 189 static_cast<jstring>(env->GetObjectArrayElement(array, i))); |
176 ConvertJavaStringToUTF8(env, str.obj(), &((*out)[back + i])); | 190 ConvertJavaStringToUTF8(env, str.obj(), out->data() + back + i); |
177 } | 191 } |
178 } | 192 } |
179 | 193 |
180 void AppendJavaByteArrayToByteVector(JNIEnv* env, | 194 void AppendJavaByteArrayToByteVector(JNIEnv* env, |
181 jbyteArray byte_array, | 195 jbyteArray byte_array, |
182 std::vector<uint8_t>* out) { | 196 std::vector<uint8_t>* out) { |
183 DCHECK(out); | 197 DCHECK(out); |
184 if (!byte_array) | 198 if (!byte_array) |
185 return; | 199 return; |
186 size_t len = SafeGetArrayLength(env, byte_array); | 200 size_t len = SafeGetArrayLength(env, byte_array); |
187 if (!len) | 201 if (!len) |
188 return; | 202 return; |
189 size_t back = out->size(); | 203 size_t back = out->size(); |
190 out->resize(back + len); | 204 out->resize(back + len); |
191 env->GetByteArrayRegion(byte_array, 0, len, | 205 env->GetByteArrayRegion(byte_array, 0, len, |
192 reinterpret_cast<int8_t*>(&(*out)[back])); | 206 reinterpret_cast<int8_t*>(out->data() + back)); |
193 } | 207 } |
194 | 208 |
195 void JavaByteArrayToByteVector(JNIEnv* env, | 209 void JavaByteArrayToByteVector(JNIEnv* env, |
196 jbyteArray byte_array, | 210 jbyteArray byte_array, |
197 std::vector<uint8_t>* out) { | 211 std::vector<uint8_t>* out) { |
198 DCHECK(out); | 212 DCHECK(out); |
199 DCHECK(byte_array); | 213 DCHECK(byte_array); |
200 out->clear(); | 214 out->clear(); |
201 AppendJavaByteArrayToByteVector(env, byte_array, out); | 215 AppendJavaByteArrayToByteVector(env, byte_array, out); |
202 } | 216 } |
203 | 217 |
| 218 void JavaBooleanArrayToBoolVector(JNIEnv* env, |
| 219 jbooleanArray boolean_array, |
| 220 std::vector<bool>* out) { |
| 221 DCHECK(out); |
| 222 if (!boolean_array) |
| 223 return; |
| 224 size_t len = SafeGetArrayLength(env, boolean_array); |
| 225 if (!len) |
| 226 return; |
| 227 out->resize(len); |
| 228 // It is not possible to get bool* out of vector<bool>. |
| 229 jboolean* values = env->GetBooleanArrayElements(boolean_array, nullptr); |
| 230 for (size_t i = 0; i < len; ++i) { |
| 231 out->at(i) = static_cast<bool>(values[i]); |
| 232 } |
| 233 } |
| 234 |
204 void JavaIntArrayToIntVector(JNIEnv* env, | 235 void JavaIntArrayToIntVector(JNIEnv* env, |
205 jintArray int_array, | 236 jintArray int_array, |
206 std::vector<int>* out) { | 237 std::vector<int>* out) { |
207 DCHECK(out); | 238 DCHECK(out); |
208 size_t len = SafeGetArrayLength(env, int_array); | 239 size_t len = SafeGetArrayLength(env, int_array); |
209 out->resize(len); | 240 out->resize(len); |
210 if (!len) | 241 if (!len) |
211 return; | 242 return; |
212 // TODO(jdduke): Use |out->data()| for pointer access after switch to libc++, | 243 env->GetIntArrayRegion(int_array, 0, len, out->data()); |
213 // both here and in the other conversion routines. See crbug.com/427718. | |
214 env->GetIntArrayRegion(int_array, 0, len, &(*out)[0]); | |
215 } | 244 } |
216 | 245 |
217 void JavaLongArrayToInt64Vector(JNIEnv* env, | 246 void JavaLongArrayToInt64Vector(JNIEnv* env, |
218 jlongArray long_array, | 247 jlongArray long_array, |
219 std::vector<int64_t>* out) { | 248 std::vector<int64_t>* out) { |
220 DCHECK(out); | 249 DCHECK(out); |
221 std::vector<jlong> temp; | 250 std::vector<jlong> temp; |
222 JavaLongArrayToLongVector(env, long_array, &temp); | 251 JavaLongArrayToLongVector(env, long_array, &temp); |
223 out->resize(0); | 252 out->resize(0); |
224 out->insert(out->begin(), temp.begin(), temp.end()); | 253 out->insert(out->begin(), temp.begin(), temp.end()); |
225 } | 254 } |
226 | 255 |
227 void JavaLongArrayToLongVector(JNIEnv* env, | 256 void JavaLongArrayToLongVector(JNIEnv* env, |
228 jlongArray long_array, | 257 jlongArray long_array, |
229 std::vector<jlong>* out) { | 258 std::vector<jlong>* out) { |
230 DCHECK(out); | 259 DCHECK(out); |
231 size_t len = SafeGetArrayLength(env, long_array); | 260 size_t len = SafeGetArrayLength(env, long_array); |
232 out->resize(len); | 261 out->resize(len); |
233 if (!len) | 262 if (!len) |
234 return; | 263 return; |
235 env->GetLongArrayRegion(long_array, 0, len, &(*out)[0]); | 264 env->GetLongArrayRegion(long_array, 0, len, out->data()); |
236 } | 265 } |
237 | 266 |
238 void JavaFloatArrayToFloatVector(JNIEnv* env, | 267 void JavaFloatArrayToFloatVector(JNIEnv* env, |
239 jfloatArray float_array, | 268 jfloatArray float_array, |
240 std::vector<float>* out) { | 269 std::vector<float>* out) { |
241 DCHECK(out); | 270 DCHECK(out); |
242 size_t len = SafeGetArrayLength(env, float_array); | 271 size_t len = SafeGetArrayLength(env, float_array); |
243 out->resize(len); | 272 out->resize(len); |
244 if (!len) | 273 if (!len) |
245 return; | 274 return; |
246 env->GetFloatArrayRegion(float_array, 0, len, &(*out)[0]); | 275 env->GetFloatArrayRegion(float_array, 0, len, out->data()); |
247 } | 276 } |
248 | 277 |
249 void JavaArrayOfByteArrayToStringVector( | 278 void JavaArrayOfByteArrayToStringVector( |
250 JNIEnv* env, | 279 JNIEnv* env, |
251 jobjectArray array, | 280 jobjectArray array, |
252 std::vector<std::string>* out) { | 281 std::vector<std::string>* out) { |
253 DCHECK(out); | 282 DCHECK(out); |
254 size_t len = SafeGetArrayLength(env, array); | 283 size_t len = SafeGetArrayLength(env, array); |
255 out->resize(len); | 284 out->resize(len); |
256 for (size_t i = 0; i < len; ++i) { | 285 for (size_t i = 0; i < len; ++i) { |
(...skipping 10 matching lines...) Expand all Loading... |
267 void JavaArrayOfIntArrayToIntVector( | 296 void JavaArrayOfIntArrayToIntVector( |
268 JNIEnv* env, | 297 JNIEnv* env, |
269 jobjectArray array, | 298 jobjectArray array, |
270 std::vector<std::vector<int>>* out) { | 299 std::vector<std::vector<int>>* out) { |
271 DCHECK(out); | 300 DCHECK(out); |
272 size_t len = SafeGetArrayLength(env, array); | 301 size_t len = SafeGetArrayLength(env, array); |
273 out->resize(len); | 302 out->resize(len); |
274 for (size_t i = 0; i < len; ++i) { | 303 for (size_t i = 0; i < len; ++i) { |
275 ScopedJavaLocalRef<jintArray> int_array( | 304 ScopedJavaLocalRef<jintArray> int_array( |
276 env, static_cast<jintArray>(env->GetObjectArrayElement(array, i))); | 305 env, static_cast<jintArray>(env->GetObjectArrayElement(array, i))); |
277 JavaIntArrayToIntVector(env, int_array.obj(), &((*out)[i])); | 306 JavaIntArrayToIntVector(env, int_array.obj(), &out->at(i)); |
278 } | 307 } |
279 } | 308 } |
280 | 309 |
281 } // namespace android | 310 } // namespace android |
282 } // namespace base | 311 } // namespace base |
OLD | NEW |