[jni] Throw NullPointerException for null JNI parameters

pkgs/jni/lib/src/errors.dart

@@ -37,8 +37,8 @@ final class UseAfterReleaseError extends StateError with _ExplainsRelease {
 }
 
 // TODO(#567): Use NullPointerError once it's available.
-final class JNullError extends StateError {
-  JNullError() : super('The reference was null');
+final class JNullError extends JniException {
+  JNullError() : super('The reference was null', '');
 }
 
 final class DoubleReleaseError extends StateError with _ExplainsRelease {

pkgs/jni/lib/src/jclass.dart

@@ -42,6 +42,7 @@ extension type JInstanceFieldId._fromPointer(JFieldIDPtr pointer) {
   JInstanceFieldId._(JClass jClass, String name, String signature)
       : pointer = using((arena) {
           final jClassRef = jClass.reference;
+          if (jClassRef.isNull) throw JNullError();
           return Jni.env.GetFieldID(
             jClassRef.pointer,
             name.toNativeChars(arena),
@@ -66,6 +67,7 @@ extension type JStaticFieldId._fromPointer(JFieldIDPtr pointer) {
   JStaticFieldId._(JClass jClass, String name, String signature)
       : pointer = using((arena) {
           final jClassRef = jClass.reference;
+          if (jClassRef.isNull) throw JNullError();
           return Jni.env.GetStaticFieldID(
             jClassRef.pointer,
             name.toNativeChars(arena),
@@ -93,6 +95,7 @@ extension type JInstanceMethodId._fromPointer(JMethodIDPtr pointer) {
     String signature,
   ) : pointer = using((arena) {
           final jClassRef = jClass.reference;
+          if (jClassRef.isNull) throw JNullError();
           return Jni.env.GetMethodID(
             jClassRef.pointer,
             name.toNativeChars(arena),
@@ -122,6 +125,7 @@ extension type JStaticMethodId._fromPointer(JMethodIDPtr pointer) {
     String signature,
   ) : pointer = using((arena) {
           final jClassRef = jClass.reference;
+          if (jClassRef.isNull) throw JNullError();
           return Jni.env.GetStaticMethodID(
             jClassRef.pointer,
             name.toNativeChars(arena),
@@ -148,6 +152,7 @@ extension type JConstructorId._fromPointer(JMethodIDPtr pointer) {
     String signature,
   ) : pointer = using((arena) {
           final jClassRef = jClass.reference;
+          if (jClassRef.isNull) throw JNullError();
           return Jni.env.GetMethodID(
             jClassRef.pointer,
             '<init>'.toNativeChars(arena),

pkgs/jni/lib/src/jobject.dart

@@ -107,7 +107,7 @@ class JObject {
 
   /// Constructs a [JObject] with the underlying [reference].
   JObject.fromReference(this.reference) {
-    if (reference.isNull) {
+    if (reference.isNull && runtimeType == JObject) {
       throw JNullError();
     }
   }

pkgs/jni/lib/src/types.dart

@@ -7,6 +7,7 @@ import 'dart:ffi';
 import 'package:ffi/ffi.dart';
 import 'package:meta/meta.dart' show internal;
 
+import 'errors.dart';
 import 'jni.dart';
 import 'jobject.dart';
 import 'jreference.dart';

pkgs/jni/src/dartjni.c

@@ -47,14 +47,6 @@ JniClassLookupResult FindClass(const char* name) {
   return result;
 }
 
-/// Stores class and method references for obtaining exception details
-typedef struct JniExceptionMethods {
-  jclass objectClass, exceptionClass, printStreamClass;
-  jclass byteArrayOutputStreamClass;
-  jmethodID toStringMethod, printStackTraceMethod;
-  jmethodID byteArrayOutputStreamCtor, printStreamCtor;
-} JniExceptionMethods;
-
 // Context and shared global state. Initialized once or if thread-local, initialized once in a thread.
 JniContext jni_context = {
     .jvm = NULL,
@@ -81,6 +73,8 @@ void init() {
   exceptionMethods.printStreamClass = FindClassUnchecked("java/io/PrintStream");
   exceptionMethods.byteArrayOutputStreamClass =
       FindClassUnchecked("java/io/ByteArrayOutputStream");
+  exceptionMethods.runtimeExceptionClass =
+      FindClassUnchecked("java/lang/RuntimeException");
   load_method(exceptionMethods.objectClass, &exceptionMethods.toStringMethod,
               "toString", "()Ljava/lang/String;");
   load_method(exceptionMethods.exceptionClass,
@@ -91,6 +85,9 @@ void init() {
   load_method(exceptionMethods.printStreamClass,
               &exceptionMethods.printStreamCtor, "<init>",
               "(Ljava/io/OutputStream;)V");
+  load_method(exceptionMethods.runtimeExceptionClass,
+              &exceptionMethods.runtimeExceptionCtor, "<init>",
+              "(Ljava/lang/String;)V");
 }
 
 void deinit() {
@@ -109,6 +106,7 @@ void deinit() {
     (*jniEnv)->DeleteGlobalRef(jniEnv, exceptionMethods.printStreamClass);
     (*jniEnv)->DeleteGlobalRef(jniEnv,
                                exceptionMethods.byteArrayOutputStreamClass);
+    (*jniEnv)->DeleteGlobalRef(jniEnv, exceptionMethods.runtimeExceptionClass);
   }
 }
 

pkgs/jni/src/dartjni.h

@@ -119,18 +119,31 @@ typedef struct CallbackResult {
   jobject object;
 } CallbackResult;
 
-typedef struct JniLocks {
+typedef struct JniContextLocks {
   MutexLock classLoadingLock;
-} JniLocks;
+} JniContextLocks;
 
 /// Stores the global state of the JNI.
 typedef struct JniContext {
   JavaVM* jvm;
   jobject classLoader;
   jmethodID loadClassMethod;
-  JniLocks locks;
+  JniContextLocks locks;
 } JniContext;
 
+// Forward declaration for JniExceptionMethods
+typedef struct JniExceptionMethods {
+  jclass objectClass, exceptionClass, printStreamClass;
+  jclass byteArrayOutputStreamClass;
+  jclass runtimeExceptionClass;
+  jmethodID toStringMethod, printStackTraceMethod;
+  jmethodID byteArrayOutputStreamCtor, printStreamCtor;
+  jmethodID runtimeExceptionCtor;
+} JniExceptionMethods;
+
+// External reference to exception methods (defined in dartjni.c)
+extern JniExceptionMethods exceptionMethods;
+
 // jniEnv for this thread, used by inline functions in this header,
 // therefore declared as extern.
 extern THREAD_LOCAL JNIEnv* jniEnv;
@@ -308,6 +321,58 @@ static inline jthrowable check_exception() {
   return to_global_ref(exception);
 }
 
+/// Creates a RuntimeException for null parameter errors.
+/// Returns a global reference to the exception.
+/// Uses cached RuntimeException class/constructor initialized during JVM init.
+static inline jthrowable create_null_parameter_exception(
+    const char* param_name) {
+  // Use cached RuntimeException class and constructor from exceptionMethods
+  jclass runtime_exception_class = exceptionMethods.runtimeExceptionClass;
+  jmethodID constructor = exceptionMethods.runtimeExceptionCtor;
+
+  // If not initialized yet (shouldn't happen after init), return NULL
+  // This provides safety during early bootstrap before exception methods are cached
+  if (runtime_exception_class == NULL || constructor == NULL) {
+    return NULL;
+  }
+
+  // Create error message
+  char message[256];
+  snprintf(message, sizeof(message), "Parameter %s is null", param_name);
+  jstring message_str = (*jniEnv)->NewStringUTF(jniEnv, message);
+
+  if (message_str == NULL) {
+    // Can't create string - bail out
+    return NULL;
+  }
+
+  // Clear any pending exceptions before creating our exception
+  if ((*jniEnv)->ExceptionCheck(jniEnv)) {
+    (*jniEnv)->ExceptionClear(jniEnv);
+  }
+
+  // Create the RuntimeException instance
+  jobject exception = (*jniEnv)->NewObject(jniEnv, runtime_exception_class,
+                                           constructor, message_str);
+
+  // Clean up local reference to message string
+  (*jniEnv)->DeleteLocalRef(jniEnv, message_str);
+
+  if (exception == NULL) {
+    // Failed to create exception - clear any errors and bail
+    if ((*jniEnv)->ExceptionCheck(jniEnv)) {
+      (*jniEnv)->ExceptionClear(jniEnv);
+    }
+    return NULL;
+  }
+
+  // Convert to global reference
+  jthrowable global_exception = (*jniEnv)->NewGlobalRef(jniEnv, exception);
+  (*jniEnv)->DeleteLocalRef(jniEnv, exception);
+
+  return global_exception;
+}
+
 static inline JniResult to_global_ref_result(jobject ref) {
   JniResult result;
   result.exception = check_exception();