[jnigen] Array support (#118)

Added support for Java arrays. Closed #69.

* `jni`: Added `JniArray<T>` and `JniType<T>` that includes signature information about Java types.

* `jnigen` generates an extension for `JniArray<GeneratedClass>` so we can use `operator []` and `operator []=` on all arrays. `jni` types also have this extension.

* Arrays also have a `setRange` method similar to `List`s.

* `jnigen` generates a private type class that extends `JniType<GeneratedClass>` accessible through `.type` static getter. This is useful for creating arrays since they require a type parameter like `JniArray(JniString.type, 5)` which creates an array of `JniString` with a length of 5.

Author: HosseinYousefi

pkgs/jni/example/integration_test/on_device_jni_test.dart

@@ -75,13 +75,13 @@ void main() {
   // Actually it's not even required to get a reference to class
   testWidgets("invoke_", (t) async {
     final m = Jni.invokeStaticMethod<int>("java/lang/Long", "min", "(JJ)J",
-        [JValueLong(1234), JValueLong(1324)], JniType.longType);
+        [JValueLong(1234), JValueLong(1324)], JniCallType.longType);
     expect(m, equals(1234));
   });
 
   testWidgets("retrieve_", (t) async {
     final maxLong = Jni.retrieveStaticField<int>(
-        "java/lang/Short", "MAX_VALUE", "S", JniType.shortType);
+        "java/lang/Short", "MAX_VALUE", "S", JniCallType.shortType);
     expect(maxLong, equals(32767));
   });
 
@@ -105,7 +105,7 @@ void main() {
 
   testWidgets("Passing strings in arguments", (t) async {
     final twelve = Jni.invokeStaticMethod<int>("java/lang/Byte", "parseByte",
-        "(Ljava/lang/String;)B", ["12"], JniType.byteType);
+        "(Ljava/lang/String;)B", ["12"], JniCallType.byteType);
     expect(twelve, equals(12));
   });
 

pkgs/jni/example/lib/main.dart

@@ -51,7 +51,7 @@ double randomDouble() {
 int uptime() {
   return Jni.findJniClass("android/os/SystemClock").use(
     (systemClock) => systemClock.callStaticMethodByName<int>(
-        "uptimeMillis", "()J", [], JniType.longType),
+        "uptimeMillis", "()J", [], JniCallType.longType),
   );
 }
 

pkgs/jni/ffigen.yaml

@@ -19,6 +19,9 @@ headers:
     - 'third_party/jni.h' # jni.h from Android NDK
 compiler-opts:
   - '-Ithird_party/'
+enums:
+  rename:
+    'JniType': 'JniCallType'
 functions:
   exclude: # Exclude init functions supposed to be defined in loaded DLL, not JNI
     - 'JNI_.*'

pkgs/jni/lib/src/accessors.dart

@@ -76,6 +76,11 @@ extension JniIdLookupResultMethods on JniPointerResult {
     _check(exception);
     return id.cast<jfieldID_>();
   }
+
+  Pointer<Void> get checkedRef {
+    _check(exception);
+    return id;
+  }
 }
 
 extension JniClassLookupResultMethods on JniClassLookupResult {

pkgs/jni/lib/src/jni_array.dart

@@ -0,0 +1,308 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// ignore_for_file: unnecessary_cast
+
+part of 'jni_object.dart';
+
+class JniArray<E> extends JniObject {
+  /// The type which includes information such as the signature of this class.
+  static JniType<JniArray<T>> type<T>(JniType<T> innerType) =>
+      _JniArrayType(innerType);
+
+  /// Construct a new [JniArray] with [reference] as its underlying reference.
+  JniArray.fromRef(JArray reference) : super.fromRef(reference);
+
+  JniArray(JniType<E> typeClass, int length)
+      : super.fromRef(
+          (typeClass._type == JniCallType.objectType)
+              ? _accessors
+                  .newObjectArray(
+                      length, typeClass._getClass().reference, nullptr)
+                  .checkedRef
+              : _accessors
+                  .newPrimitiveArray(length, typeClass._type)
+                  .checkedRef,
+        );
+
+  int? _length;
+
+  JniResult elementAt(int index, int type) {
+    RangeError.checkValidIndex(index, this);
+    return _accessors.getArrayElement(reference, index, type);
+  }
+
+  /// The number of elements in this array.
+  int get length {
+    return _length ??= _env.GetArrayLength(reference);
+  }
+}
+
+extension NativeJniArray<E extends NativeType> on JniArray<E> {
+  void _allocate(int size, void Function(Pointer<E> ptr) use) {
+    using((arena) {
+      final ptr = arena.allocate<E>(size);
+      use(ptr);
+    }, malloc);
+  }
+}
+
+extension BoolJniArray on JniArray<JBoolean> {
+  bool operator [](int index) {
+    return elementAt(index, JniCallType.booleanType).boolean;
+  }
+
+  void operator []=(int index, bool value) {
+    RangeError.checkValidIndex(index, this);
+    _allocate(sizeOf<JBoolean>(), (ptr) {
+      ptr.value = value ? 1 : 0;
+      _env.SetBooleanArrayRegion(reference, index, 1, ptr);
+    });
+  }
+
+  void setRange(int start, int end, Iterable<bool> iterable,
+      [int skipCount = 0]) {
+    RangeError.checkValidRange(start, end, length);
+    final size = end - start;
+    final it = iterable.skip(skipCount).take(size);
+    _allocate(sizeOf<JBoolean>() * size, (ptr) {
+      it.forEachIndexed((index, element) {
+        ptr[index] = element ? 1 : 0;
+      });
+      _env.SetBooleanArrayRegion(reference, start, size, ptr);
+    });
+  }
+}
+
+extension ByteJniArray on JniArray<JByte> {
+  int operator [](int index) {
+    return elementAt(index, JniCallType.byteType).byte;
+  }
+
+  void operator []=(int index, int value) {
+    RangeError.checkValidIndex(index, this);
+    _allocate(sizeOf<JByte>(), (ptr) {
+      ptr.value = value;
+      _env.SetByteArrayRegion(reference, index, 1, ptr);
+    });
+  }
+
+  void setRange(int start, int end, Iterable<int> iterable,
+      [int skipCount = 0]) {
+    RangeError.checkValidRange(start, end, length);
+    final size = end - start;
+    final it = iterable.skip(skipCount).take(size);
+    _allocate(sizeOf<JByte>() * size, (ptr) {
+      it.forEachIndexed((index, element) {
+        ptr[index] = element;
+      });
+      _env.SetByteArrayRegion(reference, start, size, ptr);
+    });
+  }
+}
+
+extension CharJniArray on JniArray<JChar> {
+  String operator [](int index) {
+    return String.fromCharCode(
+      elementAt(index, JniCallType.charType).char,
+    );
+  }
+
+  void operator []=(int index, String value) {
+    RangeError.checkValidIndex(index, this);
+    _allocate(sizeOf<JChar>(), (ptr) {
+      ptr.value = value.codeUnits.first;
+      _env.SetCharArrayRegion(reference, index, 1, ptr);
+    });
+  }
+
+  void setRange(int start, int end, Iterable<String> iterable,
+      [int skipCount = 0]) {
+    RangeError.checkValidRange(start, end, length);
+    final size = end - start;
+    final it = iterable.skip(skipCount).take(size);
+    _allocate(sizeOf<JChar>() * size, (ptr) {
+      it.forEachIndexed((index, element) {
+        ptr[index] = element.codeUnits.first;
+      });
+      _env.SetCharArrayRegion(reference, start, size, ptr);
+    });
+  }
+}
+
+extension ShortJniArray on JniArray<JShort> {
+  int operator [](int index) {
+    return elementAt(index, JniCallType.shortType).short;
+  }
+
+  void operator []=(int index, int value) {
+    RangeError.checkValidIndex(index, this);
+    _allocate(sizeOf<JShort>(), (ptr) {
+      ptr.value = value;
+      _env.SetShortArrayRegion(reference, index, 1, ptr);
+    });
+  }
+
+  void setRange(int start, int end, Iterable<int> iterable,
+      [int skipCount = 0]) {
+    RangeError.checkValidRange(start, end, length);
+    final size = end - start;
+    final it = iterable.skip(skipCount).take(size);
+    _allocate(sizeOf<JShort>() * size, (ptr) {
+      it.forEachIndexed((index, element) {
+        ptr[index] = element;
+      });
+      _env.SetShortArrayRegion(reference, start, size, ptr);
+    });
+  }
+}
+
+extension IntJniArray on JniArray<JInt> {
+  int operator [](int index) {
+    return elementAt(index, JniCallType.intType).integer;
+  }
+
+  void operator []=(int index, int value) {
+    RangeError.checkValidIndex(index, this);
+    _allocate(sizeOf<JInt>(), (ptr) {
+      ptr.value = value;
+      _env.SetIntArrayRegion(reference, index, 1, ptr);
+    });
+  }
+
+  void setRange(int start, int end, Iterable<int> iterable,
+      [int skipCount = 0]) {
+    RangeError.checkValidRange(start, end, length);
+    final size = end - start;
+    final it = iterable.skip(skipCount).take(size);
+    _allocate(sizeOf<JInt>() * size, (ptr) {
+      it.forEachIndexed((index, element) {
+        ptr[index] = element;
+      });
+      _env.SetIntArrayRegion(reference, start, size, ptr);
+    });
+  }
+}
+
+extension LongJniArray on JniArray<JLong> {
+  int operator [](int index) {
+    return elementAt(index, JniCallType.longType).long;
+  }
+
+  void operator []=(int index, int value) {
+    RangeError.checkValidIndex(index, this);
+    _allocate(sizeOf<JLong>(), (ptr) {
+      ptr.value = value;
+      _env.SetLongArrayRegion(reference, index, 1, ptr);
+    });
+  }
+
+  void setRange(int start, int end, Iterable<int> iterable,
+      [int skipCount = 0]) {
+    RangeError.checkValidRange(start, end, length);
+    final size = end - start;
+    final it = iterable.skip(skipCount).take(size);
+    _allocate(sizeOf<JLong>() * size, (ptr) {
+      it.forEachIndexed((index, element) {
+        ptr[index] = element;
+      });
+      _env.SetLongArrayRegion(reference, start, size, ptr);
+    });
+  }
+}
+
+extension FloatJniArray on JniArray<JFloat> {
+  double operator [](int index) {
+    return elementAt(index, JniCallType.floatType).float;
+  }
+
+  void operator []=(int index, double value) {
+    RangeError.checkValidIndex(index, this);
+    _allocate(sizeOf<JFloat>(), (ptr) {
+      ptr.value = value;
+      _env.SetFloatArrayRegion(reference, index, 1, ptr);
+    });
+  }
+
+  void setRange(int start, int end, Iterable<double> iterable,
+      [int skipCount = 0]) {
+    RangeError.checkValidRange(start, end, length);
+    final size = end - start;
+    final it = iterable.skip(skipCount).take(size);
+    _allocate(sizeOf<JFloat>() * size, (ptr) {
+      it.forEachIndexed((index, element) {
+        ptr[index] = element;
+      });
+      _env.SetFloatArrayRegion(reference, start, size, ptr);
+    });
+  }
+}
+
+extension DoubleJniArray on JniArray<JDouble> {
+  double operator [](int index) {
+    return elementAt(index, JniCallType.doubleType).doubleFloat;
+  }
+
+  void operator []=(int index, double value) {
+    RangeError.checkValidIndex(index, this);
+    _allocate(sizeOf<JDouble>(), (ptr) {
+      ptr.value = value;
+      _env.SetDoubleArrayRegion(reference, index, 1, ptr);
+    });
+  }
+
+  void setRange(int start, int end, Iterable<double> iterable,
+      [int skipCount = 0]) {
+    RangeError.checkValidRange(start, end, length);
+    final size = end - start;
+    final it = iterable.skip(skipCount).take(size);
+    _allocate(sizeOf<JDouble>() * size, (ptr) {
+      it.forEachIndexed((index, element) {
+        ptr[index] = element;
+      });
+      _env.SetDoubleArrayRegion(reference, start, size, ptr);
+    });
+  }
+}
+
+extension ObjectJniArray<T extends JniObject> on JniArray<T> {
+  JniObject operator [](int index) {
+    return JniObject.fromRef(elementAt(index, JniCallType.objectType).object);
+  }
+
+  void operator []=(int index, JniObject value) {
+    RangeError.checkValidIndex(index, this);
+    _env.SetObjectArrayElement(reference, index, value.reference);
+  }
+
+  void setRange(int start, int end, Iterable<JniObject> iterable,
+      [int skipCount = 0]) {
+    RangeError.checkValidRange(start, end, length);
+    final size = end - start;
+    final it = iterable.skip(skipCount).take(size);
+    it.forEachIndexed((index, element) {
+      this[index] = element;
+    });
+  }
+}
+
+extension ArrayJniArray<T> on JniArray<JniArray<T>> {
+  JniArray<T> operator [](int index) {
+    return JniArray<T>.fromRef(elementAt(index, JniCallType.objectType).object);
+  }
+
+  void operator []=(int index, JniArray<T> value) {
+    (this as JniArray<JniObject>)[index] = value;
+  }
+}
+
+extension StringJniArray on JniArray<JniString> {
+  JniString operator [](int index) {
+    return JniString.fromRef(elementAt(index, JniCallType.objectType).object);
+  }
+
+  void operator []=(int index, JniString value) {
+    (this as JniArray<JniObject>)[index] = value;
+  }
+}

pkgs/jni/lib/src/jni_exceptions.dart

@@ -53,16 +53,16 @@ class NoJvmInstanceException implements Exception {
 
 extension JniTypeNames on int {
   static const _names = {
-    JniType.booleanType: 'bool',
-    JniType.byteType: 'byte',
-    JniType.shortType: 'short',
-    JniType.charType: 'char',
-    JniType.intType: 'int',
-    JniType.longType: 'long',
-    JniType.floatType: 'float',
-    JniType.doubleType: 'double',
-    JniType.objectType: 'object',
-    JniType.voidType: 'void',
+    JniCallType.booleanType: 'bool',
+    JniCallType.byteType: 'byte',
+    JniCallType.shortType: 'short',
+    JniCallType.charType: 'char',
+    JniCallType.intType: 'int',
+    JniCallType.longType: 'long',
+    JniCallType.floatType: 'float',
+    JniCallType.doubleType: 'double',
+    JniCallType.objectType: 'object',
+    JniCallType.voidType: 'void',
   };
   String str() => _names[this]!;
 }