fix(jni): dart to native type conversion (#3372)

* Update

* Update

* Fix test

* Update

* Update

* Update

* Update

* Add JNI utility tests for Dart to Java object conversion

This commit introduces a new test file for verifying the conversion of Dart objects to JNI types, including primitives, lists, and maps. The tests ensure that null values are dropped appropriately and that nested structures are handled correctly. The tests are designed to run on the Android platform only.

* Rename native FFI JNI utility test file to native JNI utility test for clarity

* Refactor JNI utility tests to improve clarity and consistency

This commit updates the JNI utility tests by renaming assertion functions for better readability and consistency. The changes include replacing direct assertions with dedicated helper functions that check for equality, ensuring null checks are performed, and enhancing the overall structure of the test cases. This refactor aims to improve maintainability and clarity in the test suite.

* Remove null checks from setContexts and setExtra methods in SentryNativeJava class for cleaner code.

* Refactor JNI utility tests to enhance structure and readability

This commit updates the JNI utility tests by restructuring the test cases for better clarity and maintainability. Key changes include the introduction of local variables for input data, improved assertion handling with arena management, and the renaming of helper functions for consistency. These modifications aim to streamline the testing process and ensure accurate validation of Dart to JNI object conversions.

* Enhance JNI utility tests by adding missing line breaks for improved readability

This commit introduces line breaks in the JNI utility test file to enhance the overall readability of the code. The changes aim to improve the visual structure of the test cases, making it easier to follow the logic and organization of the tests.

Author: buenaflor

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Dart to native type conversion ([#3372](https://github.com/getsentry/sentry-dart/pull/3372))
 - Revert FFI usage on iOS/macOS due to symbol stripping issues ([#3379](https://github.com/getsentry/sentry-dart/pull/3379))
 
 ### Dependencies

packages/flutter/example/integration_test/all.dart

@@ -3,10 +3,12 @@ import 'integration_test.dart' as a;
 import 'profiling_test.dart' as b;
 import 'replay_test.dart' as c;
 import 'platform_integrations_test.dart' as d;
+import 'native_jni_utils_test.dart' as e;
 
 void main() {
   a.main();
   b.main();
   c.main();
   d.main();
+  e.main();
 }

packages/flutter/example/integration_test/integration_test.dart

@@ -707,11 +707,20 @@ void main() {
     });
 
     // 1. Add a breadcrumb via Dart
+    final customObject = CustomObject();
     final testBreadcrumb = Breadcrumb(
-      message: 'test-breadcrumb-message',
-      category: 'test-category',
-      level: SentryLevel.info,
-    );
+        message: 'test-breadcrumb-message',
+        category: 'test-category',
+        level: SentryLevel.info,
+        data: {
+          'string': 'data',
+          'int': 12,
+          'bool': true,
+          'double': 12.34,
+          'map': {'nested': 'data', 'custom object': customObject},
+          'list': [1, customObject, 3],
+          'custom object': customObject
+        });
     await Sentry.addBreadcrumb(testBreadcrumb);
 
     // 2. Verify it appears in native via loadContexts
@@ -732,6 +741,17 @@ void main() {
     expect(testCrumb, isNotNull,
         reason: 'Test breadcrumb should exist in native breadcrumbs');
     expect(testCrumb['category'], equals('test-category'));
+    expect(testCrumb['level'], equals('info'));
+    expect(testCrumb['data'], isNotNull);
+    expect(testCrumb['data']['map'], isNotNull);
+    expect(testCrumb['data']['map']['nested'], equals('data'));
+    expect(testCrumb['data']['map']['custom object'],
+        equals(customObject.toString()));
+    expect(testCrumb['data']['list'], isNotNull);
+    expect(testCrumb['data']['list'][0], equals(1));
+    expect(testCrumb['data']['list'][1], equals(customObject.toString()));
+    expect(testCrumb['data']['list'][2], equals(3));
+    expect(testCrumb['data']['custom object'], equals(customObject.toString()));
 
     // 3. Clear breadcrumbs
     await Sentry.configureScope((scope) async {
@@ -751,10 +771,20 @@ void main() {
     });
 
     // 1. Set a user via Dart
+    final customObject = CustomObject();
     final testUser = SentryUser(
       id: 'test-user-id',
       email: '[email protected]',
       username: 'test-username',
+      data: {
+        'string': 'data',
+        'int': 12,
+        'bool': true,
+        'double': 12.34,
+        'map': {'nested': 'data', 'custom object': customObject},
+        'list': [1, customObject, 3],
+        'custom object': customObject
+      },
     );
     await Sentry.configureScope((scope) async {
       await scope.setUser(testUser);
@@ -769,6 +799,26 @@ void main() {
     expect(user!['id'], equals('test-user-id'));
     expect(user['email'], equals('[email protected]'));
     expect(user['username'], equals('test-username'));
+    expect(user['data']['map'], isNotNull);
+    expect(user['data']['list'], isNotNull);
+    expect(user['data']['custom object'], equals(customObject.toString()));
+
+    if (Platform.isAndroid) {
+      // On Android, the Java SDK's User.data field only supports Map<String, String>.
+      // Nested Maps and Lists are converted to Java's HashMap/ArrayList toString()
+      // format (e.g., {key=value} instead of {"key":"value"}).
+      expect(user['data']['map'],
+          equals('{nested=data, custom object=${customObject.toString()}}'));
+      expect(
+          user['data']['list'], equals('[1, ${customObject.toString()}, 3]'));
+    } else {
+      expect(user['data']['map']['nested'], equals('data'));
+      expect(user['data']['map']['custom object'],
+          equals(customObject.toString()));
+      expect(user['data']['list'][0], equals(1));
+      expect(user['data']['list'][1], equals(customObject.toString()));
+      expect(user['data']['list'][2], equals(3));
+    }
 
     // 3. Clear user (after clearing the id should remain)
     await Sentry.configureScope((scope) async {

packages/flutter/example/integration_test/native_jni_utils_test.dart

@@ -0,0 +1,230 @@
+// ignore_for_file: depend_on_referenced_packages
+@TestOn('vm')
+
+import 'dart:io';
+
+import 'package:test/test.dart';
+import 'package:jni/jni.dart';
+import 'package:sentry_flutter/src/native/java/sentry_native_java.dart';
+
+import 'utils.dart';
+
+void main() {
+  final customObject = CustomObject();
+
+  final inputNestedMap = {
+    'innerString': 'nested',
+    'innerList': [1, null, 2],
+    'innerNull': null,
+  };
+
+  final inputList = [
+    'value',
+    1,
+    1.1,
+    true,
+    customObject,
+    ['nestedList', 2],
+    inputNestedMap,
+    null,
+  ];
+
+  final inputMap = {
+    'key': 'value',
+    'key2': 1,
+    'key3': 1.1,
+    'key4': true,
+    'key5': customObject,
+    'list': inputList,
+    'nestedMap': inputNestedMap,
+    'nullEntry': null,
+  };
+
+  final expectedNestedList = ['nestedList', 2];
+
+  final expectedNestedMap = {
+    'innerString': 'nested',
+    'innerList': [1, 2],
+    'innerNull': null,
+  };
+  final expectedList = [
+    'value',
+    1,
+    1.1,
+    true,
+    customObject.toString(),
+    expectedNestedList,
+    expectedNestedMap,
+  ];
+
+  final expectedMap = {
+    'key': 'value',
+    'key2': 1,
+    'key3': 1.1,
+    'key4': true,
+    'key5': customObject.toString(),
+    'list': expectedList,
+    'nestedMap': expectedNestedMap,
+  };
+
+  group('JNI (Android)', () {
+    test('dartToJObject converts primitives', () {
+      using((arena) {
+        _expectJniStringEquals(
+            dartToJObject('value')..releasedBy(arena), 'value');
+        _expectJniLongEquals(dartToJObject(1)..releasedBy(arena), 1);
+        _expectJniDoubleEquals(dartToJObject(1.1)..releasedBy(arena), 1.1);
+        _expectJniBoolEquals(dartToJObject(true)..releasedBy(arena), true);
+        _expectJniStringEquals(
+          dartToJObject(customObject)..releasedBy(arena),
+          customObject.toString(),
+        );
+      });
+    });
+
+    test('dartToJObject converts list (drops nulls)', () {
+      using((arena) {
+        final javaList = dartToJObject(inputList).as(JList.type(JObject.type))
+          ..releasedBy(arena);
+        _expectJniList(javaList, expectedList, arena);
+      });
+    });
+
+    test('dartToJObject converts map (drops null values)', () {
+      using((arena) {
+        final javaMap = dartToJObject(inputMap)
+            .as(JMap.type(JString.type, JObject.type))
+          ..releasedBy(arena);
+        _expectJniMap(javaMap, expectedMap, arena);
+      });
+    });
+
+    test('dartToJList', () {
+      using((arena) {
+        final javaList = dartToJList(inputList)..releasedBy(arena);
+        _expectJniList(javaList, expectedList, arena);
+      });
+    });
+
+    test('dartToJMap', () {
+      using((arena) {
+        final javaMap = dartToJMap(inputMap)..releasedBy(arena);
+        _expectJniMap(javaMap, expectedMap, arena);
+      });
+    });
+  }, skip: !Platform.isAndroid);
+}
+
+void _expectJniStringEquals(JObject? javaObject, String expected) {
+  expect(javaObject, isNotNull);
+  final javaString = javaObject!.as(JString.type);
+  expect(javaString.toDartString(releaseOriginal: true), expected);
+}
+
+void _expectJniLongEquals(JObject? javaObject, int expected) {
+  expect(javaObject, isNotNull);
+  final javaLong = javaObject!.as(JLong.type);
+  expect(javaLong.longValue(releaseOriginal: true), expected);
+}
+
+void _expectJniDoubleEquals(JObject? javaObject, double expected) {
+  expect(javaObject, isNotNull);
+  final javaDouble = javaObject!.as(JDouble.type);
+  expect(javaDouble.doubleValue(releaseOriginal: true), expected);
+}
+
+void _expectJniBoolEquals(JObject? javaObject, bool expected) {
+  expect(javaObject, isNotNull);
+  final javaBoolean = javaObject!.as(JBoolean.type);
+  expect(javaBoolean.booleanValue(releaseOriginal: true), expected);
+}
+
+JObject? _get(JMap<JString, JObject> javaMap, String key, Arena arena) =>
+    javaMap[key.toJString()..releasedBy(arena)];
+
+void _expectJniList(
+  JList<JObject> javaList,
+  List<Object?> expectedListValues,
+  Arena arena,
+) {
+  expect(javaList.length, expectedListValues.length);
+
+  _expectJniStringEquals(javaList[0], expectedListValues[0] as String);
+  _expectJniLongEquals(javaList[1], expectedListValues[1] as int);
+  _expectJniDoubleEquals(javaList[2], expectedListValues[2] as double);
+  _expectJniBoolEquals(javaList[3], expectedListValues[3] as bool);
+  _expectJniStringEquals(javaList[4], expectedListValues[4] as String);
+
+  final nestedList = javaList[5].as(JList.type(JObject.type))
+    ..releasedBy(arena);
+  final expectedNestedList = expectedListValues[5] as List<Object?>;
+  expect(nestedList.length, expectedNestedList.length);
+  _expectJniStringEquals(nestedList[0], expectedNestedList[0] as String);
+  _expectJniLongEquals(nestedList[1], expectedNestedList[1] as int);
+
+  final nestedMap = javaList[6].as(JMap.type(JString.type, JObject.type))
+    ..releasedBy(arena);
+  _expectJniNestedMap(
+    nestedMap,
+    expectedListValues[6] as Map<String, Object?>,
+    expectedNestedList.length,
+    arena,
+  );
+}
+
+void _expectJniMap(
+  JMap<JString, JObject> javaMap,
+  Map<String, Object?> expectedMapValues,
+  Arena arena,
+) {
+  expect(javaMap.length, expectedMapValues.length);
+
+  final expectedList = expectedMapValues['list']! as List<Object?>;
+  final expectedNestedList = expectedList[5] as List<Object?>;
+  final expectedNestedMap =
+      expectedMapValues['nestedMap']! as Map<String, Object?>;
+
+  _expectJniStringEquals(
+      _get(javaMap, 'key', arena), expectedMapValues['key'] as String);
+  _expectJniLongEquals(
+      _get(javaMap, 'key2', arena), expectedMapValues['key2'] as int);
+  _expectJniDoubleEquals(
+      _get(javaMap, 'key3', arena), expectedMapValues['key3'] as double);
+  _expectJniBoolEquals(
+      _get(javaMap, 'key4', arena), expectedMapValues['key4'] as bool);
+  _expectJniStringEquals(
+      _get(javaMap, 'key5', arena), expectedMapValues['key5'] as String);
+
+  final nestedList = _get(javaMap, 'list', arena)!.as(JList.type(JObject.type))
+    ..releasedBy(arena);
+  _expectJniList(nestedList, expectedList, arena);
+
+  final nestedMap = _get(javaMap, 'nestedMap', arena)!
+      .as(JMap.type(JString.type, JObject.type))
+    ..releasedBy(arena);
+  _expectJniNestedMap(
+      nestedMap, expectedNestedMap, expectedNestedList.length, arena);
+
+  expect(_get(javaMap, 'nullEntry', arena), isNull);
+}
+
+void _expectJniNestedMap(
+  JMap<JString, JObject> javaNestedMap,
+  Map<String, Object?> expectedNestedMapValues,
+  int expectedNestedListLength,
+  Arena arena,
+) {
+  _expectJniStringEquals(_get(javaNestedMap, 'innerString', arena),
+      expectedNestedMapValues['innerString'] as String);
+
+  final innerList = _get(javaNestedMap, 'innerList', arena)!
+      .as(JList.type(JObject.type))
+    ..releasedBy(arena);
+  expect(innerList.length, expectedNestedListLength);
+  _expectJniLongEquals(innerList[0],
+      (expectedNestedMapValues['innerList']! as List<Object?>)[0] as int);
+  _expectJniLongEquals(innerList[1],
+      (expectedNestedMapValues['innerList']! as List<Object?>)[1] as int);
+
+  expect(_get(javaNestedMap, 'innerNull', arena), isNull);
+}

packages/flutter/example/integration_test/utils.dart

@@ -22,3 +22,6 @@ FutureOr<void> restoreFlutterOnErrorAfter(FutureOr<void> Function() fn) async {
 }
 
 const fakeDsn = 'https://[email protected]/1234567';
+
+// Used to test for correct serialization of custom object in attributes / data.
+class CustomObject {}