jni_array.h 8.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226
  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. #ifndef BASE_ANDROID_JNI_ARRAY_H_
  5. #define BASE_ANDROID_JNI_ARRAY_H_
  6. #include <jni.h>
  7. #include <stddef.h>
  8. #include <stdint.h>
  9. #include <string>
  10. #include <vector>
  11. #include "base/android/scoped_java_ref.h"
  12. #include "base/containers/span.h"
  13. namespace base {
  14. namespace android {
  15. // Returns a new Java byte array converted from the given bytes array.
  16. BASE_EXPORT ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(JNIEnv* env,
  17. const uint8_t* bytes,
  18. size_t len);
  19. BASE_EXPORT ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(
  20. JNIEnv* env,
  21. base::span<const uint8_t> bytes);
  22. // Returns a new Java byte array converted from the given string. No UTF-8
  23. // conversion is performed.
  24. BASE_EXPORT ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(
  25. JNIEnv* env,
  26. const std::string& str);
  27. // Returns a new Java boolean array converted from the given bool array.
  28. BASE_EXPORT ScopedJavaLocalRef<jbooleanArray>
  29. ToJavaBooleanArray(JNIEnv* env, const bool* bools, size_t len);
  30. // Returns a new Java int array converted from the given int array.
  31. BASE_EXPORT ScopedJavaLocalRef<jintArray> ToJavaIntArray(
  32. JNIEnv* env, const int* ints, size_t len);
  33. BASE_EXPORT ScopedJavaLocalRef<jintArray> ToJavaIntArray(
  34. JNIEnv* env,
  35. base::span<const int> ints);
  36. // Returns a new Java long array converted from the given int64_t array.
  37. BASE_EXPORT ScopedJavaLocalRef<jlongArray> ToJavaLongArray(JNIEnv* env,
  38. const int64_t* longs,
  39. size_t len);
  40. BASE_EXPORT ScopedJavaLocalRef<jlongArray> ToJavaLongArray(
  41. JNIEnv* env,
  42. base::span<const int64_t> longs);
  43. // Returns a new Java float array converted from the given C++ float array.
  44. BASE_EXPORT ScopedJavaLocalRef<jfloatArray> ToJavaFloatArray(
  45. JNIEnv* env, const float* floats, size_t len);
  46. BASE_EXPORT ScopedJavaLocalRef<jfloatArray> ToJavaFloatArray(
  47. JNIEnv* env,
  48. base::span<const float> floats);
  49. // Returns a new Java double array converted from the given C++ double array.
  50. BASE_EXPORT ScopedJavaLocalRef<jdoubleArray>
  51. ToJavaDoubleArray(JNIEnv* env, const double* doubles, size_t len);
  52. BASE_EXPORT ScopedJavaLocalRef<jdoubleArray> ToJavaDoubleArray(
  53. JNIEnv* env,
  54. base::span<const double> doubles);
  55. // Returns a new clazz[] with the content of |v|.
  56. BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfObjects(
  57. JNIEnv* env,
  58. ScopedJavaLocalRef<jclass> clazz,
  59. base::span<const ScopedJavaLocalRef<jobject>> v);
  60. // Returns a new Object[] with the content of |v|.
  61. BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfObjects(
  62. JNIEnv* env,
  63. base::span<const ScopedJavaLocalRef<jobject>> v);
  64. BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfObjects(
  65. JNIEnv* env,
  66. base::span<const ScopedJavaGlobalRef<jobject>> v);
  67. // Returns a new Type[] with the content of |v|.
  68. BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToTypedJavaArrayOfObjects(
  69. JNIEnv* env,
  70. base::span<const ScopedJavaLocalRef<jobject>> v,
  71. ScopedJavaLocalRef<jclass> type);
  72. BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToTypedJavaArrayOfObjects(
  73. JNIEnv* env,
  74. base::span<const ScopedJavaGlobalRef<jobject>> v,
  75. ScopedJavaLocalRef<jclass> type);
  76. // Returns a array of Java byte array converted from |v|.
  77. BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray(
  78. JNIEnv* env,
  79. base::span<const std::string> v);
  80. BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray(
  81. JNIEnv* env,
  82. base::span<const std::vector<uint8_t>> v);
  83. BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStrings(
  84. JNIEnv* env,
  85. base::span<const std::string> v);
  86. BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStrings(
  87. JNIEnv* env,
  88. base::span<const std::u16string> v);
  89. BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStringArray(
  90. JNIEnv* env,
  91. base::span<const std::vector<std::string>> v);
  92. BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStringArray(
  93. JNIEnv* env,
  94. base::span<const std::vector<std::u16string>> v);
  95. // Converts a Java string array to a native array.
  96. BASE_EXPORT void AppendJavaStringArrayToStringVector(
  97. JNIEnv* env,
  98. const JavaRef<jobjectArray>& array,
  99. std::vector<std::u16string>* out);
  100. BASE_EXPORT void AppendJavaStringArrayToStringVector(
  101. JNIEnv* env,
  102. const JavaRef<jobjectArray>& array,
  103. std::vector<std::string>* out);
  104. // Appends the Java bytes in |bytes_array| onto the end of |out|.
  105. BASE_EXPORT void AppendJavaByteArrayToByteVector(
  106. JNIEnv* env,
  107. const JavaRef<jbyteArray>& byte_array,
  108. std::vector<uint8_t>* out);
  109. // Replaces the content of |out| with the Java bytes in |byte_array|.
  110. BASE_EXPORT void JavaByteArrayToByteVector(
  111. JNIEnv* env,
  112. const JavaRef<jbyteArray>& byte_array,
  113. std::vector<uint8_t>* out);
  114. // Replaces the content of |out| with the Java bytes in |byte_array|. No UTF-8
  115. // conversion is performed.
  116. BASE_EXPORT void JavaByteArrayToString(JNIEnv* env,
  117. const JavaRef<jbyteArray>& byte_array,
  118. std::string* out);
  119. // Replaces the content of |out| with the Java booleans in |boolean_array|.
  120. BASE_EXPORT void JavaBooleanArrayToBoolVector(
  121. JNIEnv* env,
  122. const JavaRef<jbooleanArray>& boolean_array,
  123. std::vector<bool>* out);
  124. // Replaces the content of |out| with the Java ints in |int_array|.
  125. BASE_EXPORT void JavaIntArrayToIntVector(JNIEnv* env,
  126. const JavaRef<jintArray>& int_array,
  127. std::vector<int>* out);
  128. // Replaces the content of |out| with the Java longs in |long_array|.
  129. BASE_EXPORT void JavaLongArrayToInt64Vector(
  130. JNIEnv* env,
  131. const JavaRef<jlongArray>& long_array,
  132. std::vector<int64_t>* out);
  133. // Replaces the content of |out| with the Java longs in |long_array|.
  134. BASE_EXPORT void JavaLongArrayToLongVector(
  135. JNIEnv* env,
  136. const JavaRef<jlongArray>& long_array,
  137. std::vector<jlong>* out);
  138. // Replaces the content of |out| with the Java floats in |float_array|.
  139. BASE_EXPORT void JavaFloatArrayToFloatVector(
  140. JNIEnv* env,
  141. const JavaRef<jfloatArray>& float_array,
  142. std::vector<float>* out);
  143. // Replaces the content of |out| with the Java doubles in |double_array|.
  144. BASE_EXPORT void JavaDoubleArrayToDoubleVector(
  145. JNIEnv* env,
  146. const JavaRef<jdoubleArray>& double_array,
  147. std::vector<double>* out);
  148. // Assuming |array| is an byte[][] (array of byte arrays), replaces the
  149. // content of |out| with the corresponding vector of strings. No UTF-8
  150. // conversion is performed.
  151. BASE_EXPORT void JavaArrayOfByteArrayToStringVector(
  152. JNIEnv* env,
  153. const JavaRef<jobjectArray>& array,
  154. std::vector<std::string>* out);
  155. // Assuming |array| is an byte[][] (array of byte arrays), replaces the
  156. // content of |out| with the corresponding vector of vector of uint8. No UTF-8
  157. // conversion is performed.
  158. BASE_EXPORT void JavaArrayOfByteArrayToBytesVector(
  159. JNIEnv* env,
  160. const JavaRef<jobjectArray>& array,
  161. std::vector<std::vector<uint8_t>>* out);
  162. // Assuming |array| is an String[][] (array of String arrays), replaces the
  163. // content of |out| with the corresponding vector of string vectors.
  164. BASE_EXPORT void Java2dStringArrayTo2dStringVector(
  165. JNIEnv* env,
  166. const JavaRef<jobjectArray>& array,
  167. std::vector<std::vector<std::string>>* out);
  168. // Assuming |array| is an String[][] (array of String arrays), replaces the
  169. // content of |out| with the corresponding vector of string vectors. No UTF-8
  170. // conversion is performed.
  171. BASE_EXPORT void Java2dStringArrayTo2dStringVector(
  172. JNIEnv* env,
  173. const JavaRef<jobjectArray>& array,
  174. std::vector<std::vector<std::u16string>>* out);
  175. // Assuming |array| is an int[][] (array of int arrays), replaces the
  176. // contents of |out| with the corresponding vectors of ints.
  177. BASE_EXPORT void JavaArrayOfIntArrayToIntVector(
  178. JNIEnv* env,
  179. const JavaRef<jobjectArray>& array,
  180. std::vector<std::vector<int>>* out);
  181. } // namespace android
  182. } // namespace base
  183. #endif // BASE_ANDROID_JNI_ARRAY_H_