[jnigen] Generic support (#136)

Added support for Generics – Closed #66, Closed #73 

* TypeClasses are now public and have `fromRef`
* Casting is possible between different types.
* Nested generic classes are also supported.

Author: HosseinYousefi

pkgs/jni/lib/src/jarray.dart

@@ -6,21 +6,31 @@
 
 part of 'types.dart';
 
-class _JArrayType<T> extends JType<JArray<T>> {
+class JArrayType<T> extends JObjType<JArray<T>> {
   final JType<T> elementType;
 
-  const _JArrayType(this.elementType);
+  const JArrayType(this.elementType);
 
   @override
   String get signature => '[${elementType.signature}';
+
+  @override
+  JArray<T> fromRef(Pointer<Void> ref) => JArray.fromRef(elementType, ref);
 }
 
 class JArray<E> extends JObject {
+  final JType<E> elementType;
+
+  @override
+  JArrayType<E> get $type => (_$type ??= type(elementType)) as JArrayType<E>;
+
   /// The type which includes information such as the signature of this class.
-  static JType<JArray<T>> type<T>(JType<T> innerType) => _JArrayType(innerType);
+  static JObjType<JArray<T>> type<T>(JType<T> innerType) =>
+      JArrayType(innerType);
 
   /// Construct a new [JArray] with [reference] as its underlying reference.
-  JArray.fromRef(JArrayPtr reference) : super.fromRef(reference);
+  JArray.fromRef(this.elementType, JArrayPtr reference)
+      : super.fromRef(reference);
 
   /// Creates a [JArray] of the given length from the given [type].
   ///
@@ -29,12 +39,14 @@ class JArray<E> extends JObject {
     if (type._type == JniCallType.objectType) {
       final clazz = type._getClass();
       final array = JArray<E>.fromRef(
+        type,
         _accessors.newObjectArray(length, clazz.reference, nullptr).checkedRef,
       );
       clazz.delete();
       return array;
     }
     return JArray.fromRef(
+      type,
       _accessors.newPrimitiveArray(length, type._type).checkedRef,
     );
   }
@@ -47,6 +59,7 @@ class JArray<E> extends JObject {
     assert(!fill.isNull, "fill must not be null.");
     final clazz = fill.getClass();
     final array = JArray<E>.fromRef(
+      fill.$type as JObjType<E>,
       _accessors
           .newObjectArray(length, clazz.reference, fill.reference)
           .checkedRef,
@@ -321,7 +334,10 @@ extension ObjectArray<T extends JObject> on JArray<T> {
 
 extension ArrayArray<T> on JArray<JArray<T>> {
   JArray<T> operator [](int index) {
-    return JArray<T>.fromRef(elementAt(index, JniCallType.objectType).object);
+    return JArray<T>.fromRef(
+      (elementType as JArrayType<T>).elementType,
+      elementAt(index, JniCallType.objectType).object,
+    );
   }
 
   void operator []=(int index, JArray<T> value) {

pkgs/jni/lib/src/jobject.dart

@@ -4,11 +4,14 @@
 
 part of 'types.dart';
 
-class _JObjectType extends JType<JObject> {
-  const _JObjectType();
+class JObjectType extends JObjType<JObject> {
+  const JObjectType();
 
   @override
   String get signature => "Ljava/lang/Object;";
+
+  @override
+  JObject fromRef(Pointer<Void> ref) => JObject.fromRef(ref);
 }
 
 Pointer<T> _getID<T extends NativeType>(
@@ -123,8 +126,11 @@ T _getField<T>(int? callType, JniResult Function(int) f) {
 ///
 /// This is the base class for classes generated by `jnigen`.
 class JObject extends JReference {
+  JObjType<JObject>? _$type;
+  JObjType<JObject> get $type => _$type ??= type;
+
   /// The type which includes information such as the signature of this class.
-  static const JType<JObject> type = _JObjectType();
+  static const JObjType<JObject> type = JObjectType();
 
   /// Construct a new [JObject] with [reference] as its underlying reference.
   JObject.fromRef(JObjectPtr reference) : super.fromRef(reference);
@@ -143,8 +149,6 @@ class JObject extends JReference {
     super.delete();
   }
 
-  // TODO(#55): Support casting JObject subclasses
-
   /// Returns [JniClass] corresponding to concrete class of this object.
   ///
   /// This may be a subclass of compile-time class.
@@ -269,6 +273,17 @@ class JObject extends JReference {
     final id = getStaticMethodID(name, signature);
     return callStaticMethod<T>(id, args, callType);
   }
+
+  /// Casts this object to another type.
+  T castTo<T extends JObject>(JObjType<T> type, {bool deleteOriginal = false}) {
+    if (deleteOriginal) {
+      _jniClass?.delete();
+      _setAsDeleted();
+      return type.fromRef(reference);
+    }
+    final newRef = _env.NewGlobalRef(reference);
+    return type.fromRef(newRef);
+  }
 }
 
 /// A high level wrapper over a JNI class reference.

pkgs/jni/lib/src/jprimitives.dart

@@ -7,11 +7,11 @@ part of 'types.dart';
 abstract class JPrimitive {}
 
 abstract class JByte extends JPrimitive {
-  static const JType<JByte> type = _JByteTypeClass();
+  static const type = JByteType();
 }
 
-class _JByteTypeClass extends JType<JByte> {
-  const _JByteTypeClass();
+class JByteType extends JType<JByte> {
+  const JByteType();
 
   @override
   int get _type => JniCallType.byteType;
@@ -21,11 +21,11 @@ class _JByteTypeClass extends JType<JByte> {
 }
 
 abstract class JBoolean extends JPrimitive {
-  static const JType<JBoolean> type = _JBooleanType();
+  static const type = JBooleanType();
 }
 
-class _JBooleanType extends JType<JBoolean> {
-  const _JBooleanType();
+class JBooleanType extends JType<JBoolean> {
+  const JBooleanType();
 
   @override
   int get _type => JniCallType.booleanType;
@@ -35,11 +35,11 @@ class _JBooleanType extends JType<JBoolean> {
 }
 
 abstract class JChar extends JPrimitive {
-  static const JType<JChar> type = _JCharType();
+  static const type = JCharType();
 }
 
-class _JCharType extends JType<JChar> {
-  const _JCharType();
+class JCharType extends JType<JChar> {
+  const JCharType();
 
   @override
   int get _type => JniCallType.charType;
@@ -49,11 +49,11 @@ class _JCharType extends JType<JChar> {
 }
 
 abstract class JShort extends JPrimitive {
-  static const JType<JShort> type = _JShortType();
+  static const type = JShortType();
 }
 
-class _JShortType extends JType<JShort> {
-  const _JShortType();
+class JShortType extends JType<JShort> {
+  const JShortType();
 
   @override
   int get _type => JniCallType.shortType;
@@ -63,11 +63,11 @@ class _JShortType extends JType<JShort> {
 }
 
 abstract class JInt extends JPrimitive {
-  static const JType<JInt> type = _JIntType();
+  static const type = JIntType();
 }
 
-class _JIntType extends JType<JInt> {
-  const _JIntType();
+class JIntType extends JType<JInt> {
+  const JIntType();
 
   @override
   int get _type => JniCallType.intType;
@@ -77,11 +77,11 @@ class _JIntType extends JType<JInt> {
 }
 
 abstract class JLong extends JPrimitive {
-  static const JType<JLong> type = _JLongType();
+  static const type = JLongType();
 }
 
-class _JLongType extends JType<JLong> {
-  const _JLongType();
+class JLongType extends JType<JLong> {
+  const JLongType();
 
   @override
   int get _type => JniCallType.longType;
@@ -91,11 +91,11 @@ class _JLongType extends JType<JLong> {
 }
 
 abstract class JFloat extends JPrimitive {
-  static const JType<JFloat> type = _JFloatType();
+  static const type = JFloatType();
 }
 
-class _JFloatType extends JType<JFloat> {
-  const _JFloatType();
+class JFloatType extends JType<JFloat> {
+  const JFloatType();
 
   @override
   int get _type => JniCallType.floatType;
@@ -105,11 +105,11 @@ class _JFloatType extends JType<JFloat> {
 }
 
 abstract class JDouble extends JPrimitive {
-  static const JType<JDouble> type = _JDoubleType();
+  static const type = JDoubleType();
 }
 
-class _JDoubleType extends JType<JDouble> {
-  const _JDoubleType();
+class JDoubleType extends JType<JDouble> {
+  const JDoubleType();
 
   @override
   int get _type => JniCallType.doubleType;

pkgs/jni/lib/src/jreference.dart

@@ -25,14 +25,18 @@ abstract class JReference implements Finalizable {
   /// Returns whether this object is deleted.
   bool get isDeleted => _deleted;
 
-  /// Deletes the underlying JNI reference. Further uses will throw
-  /// [UseAfterFreeException].
-  void delete() {
+  void _setAsDeleted() {
     if (_deleted) {
       throw DoubleFreeException(this, reference);
     }
     _deleted = true;
     _finalizer.detach(this);
+  }
+
+  /// Deletes the underlying JNI reference. Further uses will throw
+  /// [UseAfterFreeException].
+  void delete() {
+    _setAsDeleted();
     _env.DeleteGlobalRef(reference);
   }
 

pkgs/jni/lib/src/jstring.dart

@@ -4,16 +4,22 @@
 
 part of 'types.dart';
 
-class _JStringType extends JType<JString> {
-  const _JStringType();
+class JStringType extends JObjType<JString> {
+  const JStringType();
 
   @override
   String get signature => "Ljava/lang/String;";
+
+  @override
+  JString fromRef(Pointer<Void> ref) => JString.fromRef(ref);
 }
 
 class JString extends JObject {
+  @override
+  JObjType<JObject> get $type => _$type ??= type;
+
   /// The type which includes information such as the signature of this class.
-  static const JType<JString> type = _JStringType();
+  static const JObjType<JString> type = JStringType();
 
   /// Construct a new [JString] with [reference] as its underlying reference.
   JString.fromRef(JStringPtr reference) : super.fromRef(reference);

pkgs/jni/lib/src/types.dart

@@ -28,9 +28,19 @@ typedef _VoidType = void;
 abstract class JType<T> {
   const JType();
 
-  int get _type => JniCallType.objectType;
+  int get _type;
 
   String get signature;
 
   JniClass _getClass() => Jni.findJniClass(signature);
 }
+
+abstract class JObjType<T extends JObject> extends JType<T> {
+  const JObjType();
+
+  @override
+  int get _type => JniCallType.objectType;
+
+  /// Creates an object from this type using the reference.
+  T fromRef(Pointer<Void> ref);
+}

pkgs/jni/test/jobject_test.dart

@@ -191,6 +191,18 @@ void main() {
         .use((f) => f.callMethodByName<int>("ordinal", "()I", []));
     expect(ordinal, equals(1));
   });
+  test("casting", () {
+    using((arena) {
+      final str = "hello".toJString()..deletedIn(arena);
+      final obj = str.castTo(JObject.type)..deletedIn(arena);
+      final backToStr = obj.castTo(JString.type);
+      expect(backToStr.toDartString(), str.toDartString());
+      final _ = backToStr.castTo(JObject.type, deleteOriginal: true)
+        ..deletedIn(arena);
+      expect(backToStr.toDartString, throwsA(isA<UseAfterFreeException>()));
+      expect(backToStr.delete, throwsA(isA<DoubleFreeException>()));
+    });
+  });
 
   test("Isolate", () {
     Isolate.spawn(doSomeWorkInIsolate, null);