[jnigen] Boxed types + Map + Set + List (#271)

* make primitive types lowercased
* remove part statements
* add jset, jlist, jmap and jiterator
* add JNumber and JBoolean, JInteger and other boxed types
* increase coverage

Author: HosseinYousefi

pkgs/jni/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.5.0-dev.0
+* **Breaking Change** ([#137](https://github.com/dart-lang/jnigen/issues/137)): Java primitive types are now all lowercase like `jint`, `jshort`, ...
+* The bindings for `java.util.Set`, `java.util.Map`, `java.util.List` and the numeric types like `java.lang.Integer`, `java.lang.Boolean`, ... are now included in `package:jni`.
+
 ## 0.4.0
 * Type classes now have `superCount` and `superType` getters used for type inference.
 

pkgs/jni/example/integration_test/on_device_jni_test.dart

@@ -6,8 +6,12 @@ import 'package:flutter_test/flutter_test.dart';
 
 import '../../test/global_env_test.dart' as global_env_test;
 import '../../test/exception_test.dart' as exception_test;
+import '../../test/jlist_test.dart' as jlist_test;
+import '../../test/jmap_test.dart' as jmap_test;
 import '../../test/jobject_test.dart' as jobject_test;
+import '../../test/jset_test.dart' as jset_test;
 import '../../test/jarray_test.dart' as jarray_test;
+import '../../test/boxed_test.dart' as boxed_test;
 import '../../test/type_test.dart' as type_test;
 import '../../test/load_test.dart' as load_test;
 
@@ -19,8 +23,12 @@ void main() {
   final testSuites = [
     global_env_test.run,
     exception_test.run,
+    jlist_test.run,
+    jmap_test.run,
     jobject_test.run,
+    jset_test.run,
     jarray_test.run,
+    boxed_test.run,
     type_test.run,
     load_test.run,
   ];

pkgs/jni/lib/internal_helpers_for_jnigen.dart

@@ -7,5 +7,5 @@
 library internal_helpers_for_jnigen;
 
 export 'src/jni.dart' show ProtectedJniExtensions;
-export 'src/types.dart' show JReference;
+export 'src/jreference.dart';
 export 'src/accessors.dart';

pkgs/jni/lib/jni.dart

@@ -64,7 +64,14 @@ export 'src/third_party/generated_bindings.dart'
     hide JniBindings, JniEnv, JniEnv1, JniExceptionDetails;
 export 'src/jni.dart' hide ProtectedJniExtensions;
 export 'src/jvalues.dart' hide JValueArgs, toJValues;
-export 'src/types.dart' hide JReference;
+export 'src/types.dart';
+export 'src/jarray.dart';
+export 'src/jexceptions.dart';
+export 'src/jobject.dart';
+export 'src/jprimitives.dart';
+export 'src/jreference.dart' show JReferenceUseExtension;
+export 'src/lang/lang.dart';
+export 'src/util/util.dart';
 
 export 'package:ffi/ffi.dart' show using, Arena;
 export 'dart:ffi' show nullptr;

pkgs/jni/lib/src/accessors.dart

@@ -7,9 +7,9 @@ import 'package:ffi/ffi.dart' show using;
 
 import 'package:jni/src/jvalues.dart';
 
+import 'jexceptions.dart';
 import 'third_party/generated_bindings.dart';
 import 'jni.dart';
-import 'types.dart';
 
 void _check(JThrowablePtr exception) {
   if (exception != nullptr) {

pkgs/jni/lib/src/jarray.dart

@@ -2,9 +2,19 @@
 // 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
+// ignore_for_file: unnecessary_cast, overridden_fields
 
-part of 'types.dart';
+import 'dart:ffi';
+
+import 'package:collection/collection.dart';
+import 'package:ffi/ffi.dart';
+import 'package:jni/src/accessors.dart';
+import 'package:jni/src/third_party/generated_bindings.dart';
+
+import 'jni.dart';
+import 'jobject.dart';
+import 'jprimitives.dart';
+import 'types.dart';
 
 class JArrayType<T> extends JObjType<JArray<T>> {
   final JType<T> elementType;
@@ -38,7 +48,7 @@ class JArray<E> extends JObject {
   final JType<E> elementType;
 
   @override
-  JArrayType<E> get $type => (_$type ??= type(elementType)) as JArrayType<E>;
+  late final JArrayType<E> $type = type(elementType) as JArrayType<E>;
 
   /// The type which includes information such as the signature of this class.
   static JObjType<JArray<T>> type<T>(JType<T> innerType) =>
@@ -52,18 +62,18 @@ class JArray<E> extends JObject {
   ///
   /// The [length] must be a non-negative integer.
   factory JArray(JType<E> type, int length) {
-    if (type._type == JniCallType.objectType && type is JObjType) {
+    if (type.callType == JniCallType.objectType && type is JObjType) {
       final clazz = (type as JObjType).getClass();
       final array = JArray<E>.fromRef(
         type,
-        _accessors.newObjectArray(length, clazz.reference, nullptr).object,
+        Jni.accessors.newObjectArray(length, clazz.reference, nullptr).object,
       );
       clazz.delete();
       return array;
     }
     return JArray.fromRef(
       type,
-      _accessors.newPrimitiveArray(length, type._type).object,
+      Jni.accessors.newPrimitiveArray(length, type.callType).object,
     );
   }
 
@@ -76,7 +86,9 @@ class JArray<E> extends JObject {
     final clazz = fill.getClass();
     final array = JArray<E>.fromRef(
       fill.$type as JObjType<E>,
-      _accessors.newObjectArray(length, clazz.reference, fill.reference).object,
+      Jni.accessors
+          .newObjectArray(length, clazz.reference, fill.reference)
+          .object,
     );
     clazz.delete();
     return array;
@@ -86,12 +98,12 @@ class JArray<E> extends JObject {
 
   JniResult elementAt(int index, int type) {
     RangeError.checkValidIndex(index, this);
-    return _accessors.getArrayElement(reference, index, type);
+    return Jni.accessors.getArrayElement(reference, index, type);
   }
 
   /// The number of elements in this array.
   int get length {
-    return _length ??= _env.GetArrayLength(reference);
+    return _length ??= Jni.env.GetArrayLength(reference);
   }
 }
 
@@ -107,7 +119,7 @@ extension NativeArray<E extends JPrimitive> on JArray<E> {
   }
 }
 
-extension BoolArray on JArray<JBoolean> {
+extension BoolArray on JArray<jboolean> {
   bool operator [](int index) {
     return elementAt(index, JniCallType.booleanType).boolean;
   }
@@ -116,7 +128,7 @@ extension BoolArray on JArray<JBoolean> {
     RangeError.checkValidIndex(index, this);
     _allocate<JBooleanMarker>(sizeOf<JBooleanMarker>(), (ptr) {
       ptr.value = value ? 1 : 0;
-      _env.SetBooleanArrayRegion(reference, index, 1, ptr);
+      Jni.env.SetBooleanArrayRegion(reference, index, 1, ptr);
     });
   }
 
@@ -129,12 +141,12 @@ extension BoolArray on JArray<JBoolean> {
       it.forEachIndexed((index, element) {
         ptr[index] = element ? 1 : 0;
       });
-      _env.SetBooleanArrayRegion(reference, start, size, ptr);
+      Jni.env.SetBooleanArrayRegion(reference, start, size, ptr);
     });
   }
 }
 
-extension ByteArray on JArray<JByte> {
+extension ByteArray on JArray<jbyte> {
   int operator [](int index) {
     return elementAt(index, JniCallType.byteType).byte;
   }
@@ -143,7 +155,7 @@ extension ByteArray on JArray<JByte> {
     RangeError.checkValidIndex(index, this);
     _allocate<JByteMarker>(sizeOf<JByteMarker>(), (ptr) {
       ptr.value = value;
-      _env.SetByteArrayRegion(reference, index, 1, ptr);
+      Jni.env.SetByteArrayRegion(reference, index, 1, ptr);
     });
   }
 
@@ -156,12 +168,12 @@ extension ByteArray on JArray<JByte> {
       it.forEachIndexed((index, element) {
         ptr[index] = element;
       });
-      _env.SetByteArrayRegion(reference, start, size, ptr);
+      Jni.env.SetByteArrayRegion(reference, start, size, ptr);
     });
   }
 }
 
-extension CharArray on JArray<JChar> {
+extension CharArray on JArray<jchar> {
   String operator [](int index) {
     return String.fromCharCode(
       elementAt(index, JniCallType.charType).char,
@@ -172,7 +184,7 @@ extension CharArray on JArray<JChar> {
     RangeError.checkValidIndex(index, this);
     _allocate<JCharMarker>(sizeOf<JCharMarker>(), (ptr) {
       ptr.value = value.codeUnits.first;
-      _env.SetCharArrayRegion(reference, index, 1, ptr);
+      Jni.env.SetCharArrayRegion(reference, index, 1, ptr);
     });
   }
 
@@ -185,12 +197,12 @@ extension CharArray on JArray<JChar> {
       it.forEachIndexed((index, element) {
         ptr[index] = element.codeUnits.first;
       });
-      _env.SetCharArrayRegion(reference, start, size, ptr);
+      Jni.env.SetCharArrayRegion(reference, start, size, ptr);
     });
   }
 }
 
-extension ShortArray on JArray<JShort> {
+extension ShortArray on JArray<jshort> {
   int operator [](int index) {
     return elementAt(index, JniCallType.shortType).short;
   }
@@ -199,7 +211,7 @@ extension ShortArray on JArray<JShort> {
     RangeError.checkValidIndex(index, this);
     _allocate<JShortMarker>(sizeOf<JShortMarker>(), (ptr) {
       ptr.value = value;
-      _env.SetShortArrayRegion(reference, index, 1, ptr);
+      Jni.env.SetShortArrayRegion(reference, index, 1, ptr);
     });
   }
 
@@ -212,12 +224,12 @@ extension ShortArray on JArray<JShort> {
       it.forEachIndexed((index, element) {
         ptr[index] = element;
       });
-      _env.SetShortArrayRegion(reference, start, size, ptr);
+      Jni.env.SetShortArrayRegion(reference, start, size, ptr);
     });
   }
 }
 
-extension IntArray on JArray<JInt> {
+extension IntArray on JArray<jint> {
   int operator [](int index) {
     return elementAt(index, JniCallType.intType).integer;
   }
@@ -226,7 +238,7 @@ extension IntArray on JArray<JInt> {
     RangeError.checkValidIndex(index, this);
     _allocate<JIntMarker>(sizeOf<JIntMarker>(), (ptr) {
       ptr.value = value;
-      _env.SetIntArrayRegion(reference, index, 1, ptr);
+      Jni.env.SetIntArrayRegion(reference, index, 1, ptr);
     });
   }
 
@@ -239,12 +251,12 @@ extension IntArray on JArray<JInt> {
       it.forEachIndexed((index, element) {
         ptr[index] = element;
       });
-      _env.SetIntArrayRegion(reference, start, size, ptr);
+      Jni.env.SetIntArrayRegion(reference, start, size, ptr);
     });
   }
 }
 
-extension LongArray on JArray<JLong> {
+extension LongArray on JArray<jlong> {
   int operator [](int index) {
     return elementAt(index, JniCallType.longType).long;
   }
@@ -253,7 +265,7 @@ extension LongArray on JArray<JLong> {
     RangeError.checkValidIndex(index, this);
     _allocate<JLongMarker>(sizeOf<JLongMarker>(), (ptr) {
       ptr.value = value;
-      _env.SetLongArrayRegion(reference, index, 1, ptr);
+      Jni.env.SetLongArrayRegion(reference, index, 1, ptr);
     });
   }
 
@@ -266,12 +278,12 @@ extension LongArray on JArray<JLong> {
       it.forEachIndexed((index, element) {
         ptr[index] = element;
       });
-      _env.SetLongArrayRegion(reference, start, size, ptr);
+      Jni.env.SetLongArrayRegion(reference, start, size, ptr);
     });
   }
 }
 
-extension FloatArray on JArray<JFloat> {
+extension FloatArray on JArray<jfloat> {
   double operator [](int index) {
     return elementAt(index, JniCallType.floatType).float;
   }
@@ -280,7 +292,7 @@ extension FloatArray on JArray<JFloat> {
     RangeError.checkValidIndex(index, this);
     _allocate<JFloatMarker>(sizeOf<JFloatMarker>(), (ptr) {
       ptr.value = value;
-      _env.SetFloatArrayRegion(reference, index, 1, ptr);
+      Jni.env.SetFloatArrayRegion(reference, index, 1, ptr);
     });
   }
 
@@ -293,12 +305,12 @@ extension FloatArray on JArray<JFloat> {
       it.forEachIndexed((index, element) {
         ptr[index] = element;
       });
-      _env.SetFloatArrayRegion(reference, start, size, ptr);
+      Jni.env.SetFloatArrayRegion(reference, start, size, ptr);
     });
   }
 }
 
-extension DoubleArray on JArray<JDouble> {
+extension DoubleArray on JArray<jdouble> {
   double operator [](int index) {
     return elementAt(index, JniCallType.doubleType).doubleFloat;
   }
@@ -307,7 +319,7 @@ extension DoubleArray on JArray<JDouble> {
     RangeError.checkValidIndex(index, this);
     _allocate<JDoubleMarker>(sizeOf<JDoubleMarker>(), (ptr) {
       ptr.value = value;
-      _env.SetDoubleArrayRegion(reference, index, 1, ptr);
+      Jni.env.SetDoubleArrayRegion(reference, index, 1, ptr);
     });
   }
 
@@ -320,7 +332,7 @@ extension DoubleArray on JArray<JDouble> {
       it.forEachIndexed((index, element) {
         ptr[index] = element;
       });
-      _env.SetDoubleArrayRegion(reference, start, size, ptr);
+      Jni.env.SetDoubleArrayRegion(reference, start, size, ptr);
     });
   }
 }
@@ -333,7 +345,7 @@ extension ObjectArray<T extends JObject> on JArray<T> {
 
   void operator []=(int index, T value) {
     RangeError.checkValidIndex(index, this);
-    _env.SetObjectArrayElement(reference, index, value.reference);
+    Jni.env.SetObjectArrayElement(reference, index, value.reference);
   }
 
   void setRange(int start, int end, Iterable<T> iterable, [int skipCount = 0]) {

pkgs/jni/lib/src/jexceptions.dart

@@ -2,7 +2,9 @@
 // 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.
 
-part of 'types.dart';
+import 'dart:ffi';
+
+import 'package:jni/src/third_party/generated_bindings.dart';
 
 abstract class JException implements Exception {}
 

pkgs/jni/lib/src/jni.dart

@@ -9,9 +9,11 @@ import 'dart:isolate';
 import 'package:ffi/ffi.dart';
 import 'package:path/path.dart';
 
+import 'jexceptions.dart';
+import 'jobject.dart';
+import 'jreference.dart';
 import 'third_party/generated_bindings.dart';
 import 'jvalues.dart';
-import 'types.dart';
 import 'accessors.dart';
 
 String _getLibraryFileName(String base) {
@@ -183,17 +185,13 @@ abstract class Jni {
     return env;
   }
 
-  static GlobalJniEnv? _env;
-
-  /// Points to a process-wide shared instance of [GlobalJniEnvStruct].
+  /// Points to a process-wide shared instance of [GlobalJniEnv].
   ///
   /// It provides an indirection over [JniEnv] so that it can be used from
   /// any thread, and always returns global object references.
-  static GlobalJniEnv get env {
-    return _env ??= GlobalJniEnv(_fetchGlobalEnv());
-  }
+  static final env = GlobalJniEnv(_fetchGlobalEnv());
 
-  static JniAccessors get accessors => JniAccessors(_bindings.GetAccessors());
+  static final accessors = JniAccessors(_bindings.GetAccessors());
 
   /// Returns a new PortContinuation.
   static JObjectPtr newPortContinuation(ReceivePort port) {