use crate::java::java_error::JavaError; use crate::java::java_field::{ JavaBooleanField, JavaByteField, JavaCharField, JavaDoubleField, JavaField, JavaFloatField, JavaIntField, JavaLongField, JavaObjectField, JavaShortField, StaticJavaBooleanField, StaticJavaByteField, StaticJavaCharField, StaticJavaDoubleField, StaticJavaFloatField, StaticJavaIntField, StaticJavaLongField, StaticJavaObjectField, StaticJavaShortField, }; use crate::java::java_type::JavaType; use crate::java::java_vm::JavaVM; use crate::java::jni_error::JNIError; use crate::java::objects::args::JavaArgs; use crate::java::objects::array::{ JavaArray, JavaBooleanArray, JavaByteArray, JavaCharArray, JavaDoubleArray, JavaFloatArray, JavaIntArray, JavaLongArray, JavaObjectArray, JavaShortArray, }; use crate::java::objects::class::{GlobalJavaClass, JavaClass}; use crate::java::objects::constructor::JavaConstructor; use crate::java::objects::java_object::JavaObject; use crate::java::objects::method::{JavaMethod, JavaObjectMethod}; use crate::java::objects::object::{GlobalJavaObject, LocalJavaObject}; use crate::java::objects::string::JavaString; use crate::java::objects::value::JavaBoolean; use crate::java::traits::GetRaw; use crate::java::util::helpers::{jni_error_to_string, ResultType}; use crate::java::vm_ptr::JavaVMPtr; use crate::objects::args::AsJavaArg; #[cfg(feature = "type_check")] use crate::signature::Signature; #[cfg(feature = "type_check")] use crate::traits::GetSignature; use crate::traits::GetSignatureRef; use crate::{ assert_non_null, define_array_methods, define_call_methods, define_field_methods, sys, }; use std::borrow::Borrow; use std::error::Error; use std::ffi::{CStr, CString}; use std::fmt::Display; use std::ops::Not; use std::ptr; use std::sync::{Arc, Mutex}; use std::thread::ThreadId; /// A wrapper around a JNIEnv. /// This manages the reference count for the current thread /// and provides convenience methods to the jvm. /// Rather than copying or creating this directly, attach a new /// thread using [`JavaVM::attach_thread`](JavaVM::attach_thread). pub struct JavaEnvWrapper<'a> { pub jvm: Option>>, pub env: *mut sys::JNIEnv, pub methods: sys::JNINativeInterface_, thread_id: ThreadId, _marker: std::marker::PhantomData<&'a *mut sys::JNIEnv>, } impl<'a> JavaEnvWrapper<'a> { /// You should probably not use this. pub(crate) fn new(jvm: Arc>, env: *mut sys::JNIEnv) -> Self { #[cfg(feature = "log")] crate::trace!( "Creating JavaEnv in thread {:?}", std::thread::current().id() ); assert_non_null!(env, "JavaEnvWrapper::new: env is null"); Self { jvm: Some(jvm), env, methods: unsafe { *(*env) }, thread_id: std::thread::current().id(), _marker: std::marker::PhantomData, } } pub unsafe fn from_raw(env: *mut sys::JNIEnv) -> Self { assert_non_null!(env, "JavaEnvWrapper::from_raw: env is null"); let mut res = Self { jvm: None, env, methods: *(*env), thread_id: std::thread::current().id(), _marker: std::marker::PhantomData, }; res.jvm = res.load_java_vm().ok(); res } fn load_java_vm(&self) -> ResultType>> { let mut vm: *mut sys::JavaVM = ptr::null_mut(); let res = unsafe { self.methods.GetJavaVM.unwrap()(self.env, &mut vm as *mut *mut sys::JavaVM) }; if res != sys::JNI_OK as _ || vm.is_null() { Err(format!("Failed to get JavaVM: {}", jni_error_to_string(res)).into()) } else { Ok(Arc::new(Mutex::new(JavaVMPtr::from_raw(vm)))) } } pub fn get_object_class(&'a self, object: JavaObject) -> ResultType> { let class = unsafe { self.methods.GetObjectClass.unwrap()(self.env, object.get_raw()) }; if self.is_err() || class.is_null() { Err(self.get_last_error(file!(), line!(), true, "GetObjectClass failed")?) } else { Ok(JavaClass::new( class, self, #[cfg(feature = "type_check")] object.get_signature().clone(), )) } } pub fn get_object_signature(&self, object: JavaObject) -> ResultType { let object_class = self.get_object_class(object.copy_ref())?; let get_class = object_class.get_object_method("getClass", "()Ljava/lang/Class;")?; let class = get_class .call(object, &[])? .ok_or("Object.getClass() returned null".to_string())?; let java_class = self.get_java_lang_class()?; let get_name = java_class.get_object_method("getName", "()Ljava/lang/String;")?; let java_name = get_name .call(JavaObject::from(class), &[])? .ok_or("Class.getName() returned null".to_string())?; // As JavaString::try_from calls get_object_signature in order // to check if the passed type is a string, we need to get the // string manually in order to prevent a stack overflow. let name = unsafe { self.get_string_utf_chars(java_name.get_raw())? }; Ok(JavaType::new(name, true)) } pub fn get_class_name(&self, object: JavaObject) -> ResultType { let object_class = self.get_object_class(object.copy_ref())?; let get_class = object_class.get_object_method("getClass", "()Ljava/lang/Class;")?; let class = get_class .call(object, &[])? .ok_or("Object.getClass() returned null".to_string())?; let java_class = self.get_java_lang_class()?; let get_name = java_class.get_object_method("getName", "()Ljava/lang/String;")?; let java_name = get_name .call(JavaObject::from(class), &[])? .ok_or("Class.getName() returned null".to_string())?; let str = JavaString::try_from(java_name)?; str.to_string() } pub fn is_instance_of(&self, object: JavaObject, classname: &str) -> ResultType { let class = self.find_class(classname, true)?; let result = unsafe { self.methods.IsInstanceOf.unwrap()(self.env, object.get_raw(), class.class()) }; if self.is_err() { Err(self.get_last_error(file!(), line!(), true, "IsInstanceOf failed")?) } else { Ok(result != 0) } } pub fn instance_of(&self, this: JavaObject, other: GlobalJavaClass) -> ResultType { let result = unsafe { self.methods.IsInstanceOf.unwrap()(self.env, this.get_raw(), other.class()) }; if self.is_err() { Err(self.get_last_error(file!(), line!(), true, "IsInstanceOf failed")?) } else { Ok(result != 0) } } pub fn throw_error(&self, message: String) { let message = CString::new(message).unwrap(); unsafe { self.methods.ThrowNew.unwrap()( self.env, self.find_class("java/lang/Exception", true) .unwrap() .class(), message.as_ptr(), ); } } pub fn throw(&self, object: JavaObject) { unsafe { self.methods.Throw.unwrap()(self.env, object.get_raw()); } } /// Check if an error has been thrown inside this environment /// /// See also [`get_last_error`](Self::get_last_error). fn is_err(&self) -> bool { unsafe { self.methods.ExceptionCheck.unwrap()(self.env) != 0 } } /// Clear the (last) pending exception from this environment. /// /// See also [`get_last_error`](Self::get_last_error). fn clear_err(&self) { unsafe { self.methods.ExceptionClear.unwrap()(self.env); } } /// Get the pending exception from this environment. /// If no exception is pending, returns an error. /// /// See also [`get_last_error`](Self::get_last_error). fn exception_occurred(&'a self) -> ResultType> { let throwable = unsafe { self.methods.ExceptionOccurred.unwrap()(self.env) }; self.clear_err(); if throwable.is_null() { Err(JNIError::from("Call to ExceptionOccurred failed").into()) } else { Ok(LocalJavaObject::new( throwable, self, #[cfg(feature = "type_check")] JavaType::object(), )) } } /// Convert the frames of the last pending exception to a rust error. /// /// See [`get_last_error`](Self::get_last_error) which uses this method. #[allow(clippy::too_many_arguments, clippy::only_used_in_recursion)] fn convert_frames( &self, frames: &mut JavaObjectArray<'_>, num_frames: i32, throwable: JavaObject, throwable_to_string: &JavaObjectMethod, throwable_get_cause: &JavaObjectMethod, throwable_get_stack_trace: &JavaObjectMethod, stack_trace_element_to_string: &JavaObjectMethod, causes: &mut Vec, stack_frames: &mut Vec, ) -> ResultType<()> { let throwable_string = throwable_to_string .call_with_errors(throwable.copy_ref(), &[], false)? .ok_or("Throwable.toString() returned null".to_string())?; causes.push(throwable_string.to_java_string()?.try_into()?); for i in 0..num_frames { let frame = frames .get_with_errors(i, false)? .ok_or("A stack frame was null".to_string())?; let frame_string = stack_trace_element_to_string .call_with_errors(JavaObject::from(&frame), &[], false)? .ok_or("StackTraceElement.toString() returned null".to_string())?; stack_frames.push(frame_string.to_java_string()?.try_into()?); } let throwable = throwable_get_cause.call_with_errors(throwable, &[], false)?; let throwable = if let Some(throwable) = throwable { JavaObject::from(throwable) } else { return Ok(()); }; let frames_obj = throwable_get_stack_trace.call_with_errors(throwable.copy_ref(), &[], false)?; let mut frames = if let Some(f) = frames_obj { JavaObjectArray::from(f) } else { return Ok(()); }; let num_frames = frames.len()?; self.convert_frames( &mut frames, num_frames, throwable.copy_ref(), throwable_to_string, throwable_get_cause, throwable_get_stack_trace, stack_trace_element_to_string, causes, stack_frames, ) } /// Get the last java error as an rust error. /// If no error is pending, returns an error. /// Clears the pending exception, converts the stack frames /// and returns the error as an [`JavaError`](JavaError). /// If this returns `Err`, an error occurred while converting the stack frames, /// if this returns `Ok`, everything was converted correctly. /// /// # Parameters /// - `file` - The (source) file the error occurred in. /// - `line` - The line the error occurred on. /// - `convert_errors` - For internal use only, just pass `true`. /// - `alt_text` - An alternative text to use when `convert_errors` is `false`. fn get_last_error( &self, file: &str, line: u32, convert_errors: bool, alt_text: &str, ) -> ResultType> { if !self.is_err() { return Err(JNIError::from("No error occurred").into()); } let mut own_stack_frames = vec![ format!("{}:{}", file, line).to_string(), format!("{}:{}", file!(), line!()).to_string(), ]; let mut stack_frames: Vec = Vec::new(); if !convert_errors { self.clear_err(); return Err(JavaError::new(vec![], own_stack_frames, alt_text.to_string()).into()); } let throwable: GlobalJavaObject = self.exception_occurred()?.try_into()?; let throwable_class = self.find_class("java/lang/Throwable", false)?; let throwable_get_cause = throwable_class.get_object_method_with_errors( "getCause", "()Ljava/lang/Throwable;", false, )?; let throwable_get_stack_trace = throwable_class.get_object_method_with_errors( "getStackTrace", "()[Ljava/lang/StackTraceElement;", false, )?; let throwable_to_string = throwable_class.get_object_method_with_errors( "toString", "()Ljava/lang/String;", false, )?; let stack_trace_element_class = self.find_class("java/lang/StackTraceElement", false)?; let stack_trace_element_to_string = stack_trace_element_class .get_object_method_with_errors("toString", "()Ljava/lang/String;", false)?; let mut frames = JavaObjectArray::from( throwable_get_stack_trace .call_with_errors(JavaObject::from(&throwable), &[], false)? .ok_or("Throwable.getStackTrace() returned null".to_string())?, ); let num_frames = frames.len()?; let mut causes: Vec = vec![]; self.convert_frames( &mut frames, num_frames, JavaObject::from(&throwable), &throwable_to_string, &throwable_get_cause, &throwable_get_stack_trace, &stack_trace_element_to_string, &mut causes, &mut stack_frames, )?; stack_frames.append(&mut own_stack_frames); Ok( JavaError::new_with_throwable(causes, stack_frames, alt_text.to_string(), throwable) .into(), ) } /// Delete the local reference of an java object. /// Make sure to only call this once as any subsequent /// calls will cause the program to segfault. /// This is not strictly required by the jvm but should be done /// for jni calls to the jvm. Do not call this if the object /// has been converted to a global reference. pub fn delete_local_ref(&self, object: sys::jobject) { assert_non_null!(object); unsafe { self.methods.DeleteLocalRef.unwrap()(self.env, object); } } /// Create a new global reference to a java object. /// /// Used by [`GlobalJavaObject`](crate::java::java_object::GlobalJavaObject) /// to create a global references from local ones. pub fn new_global_object( &self, object: sys::jobject, #[cfg(feature = "type_check")] signature: JavaType, ) -> ResultType { #[cfg(feature = "type_check")] crate::trace!("Creating global reference to object of type {}", signature); assert_non_null!(object); let obj = unsafe { self.methods.NewGlobalRef.unwrap()(self.env, object) }; if self.is_err() || obj.is_null() { self.clear_err(); Err(JNIError::new("Failed to create global reference".to_string()).into()) } else { Ok(GlobalJavaObject::new( obj, self.jvm .as_ref() .ok_or("The jvm was unset".to_string())? .clone(), #[cfg(feature = "type_check")] signature, )) } } /// Find a class by its jni class name. /// /// Used by [`JavaEnv.find_class()`](crate::java::java_env::JavaEnv::find_class) /// and [`JavaClass.by_name()`](crate::java::java_object::JavaClass::by_name). pub fn find_class( &'a self, class_name: &str, resolve_errors: bool, ) -> ResultType> { crate::trace!("Resolving class '{}'", class_name); let c_class_name = CString::new(class_name)?; let class = unsafe { self.methods.FindClass.unwrap()(self.env, c_class_name.as_ptr()) }; if self.is_err() || class.is_null() { Err(self.get_last_error( file!(), line!(), resolve_errors, format!("Could not find class '{}'", class_name).as_str(), )?) } else { Ok(JavaClass::new( class, self, #[cfg(feature = "type_check")] JavaType::new(class_name.to_string(), true), )) } } /// Get `java.lang.Class` pub fn get_java_lang_class(&'a self) -> ResultType> { crate::trace!("Getting java.lang.Class"); self.find_class("java/lang/Class", true) } pub fn find_class_by_java_name(&'a self, class_name: String) -> ResultType> { crate::trace!("Resolving class '{}'", class_name); let class = self.get_java_lang_class()?; let for_name = class.get_static_object_method( "forName", "(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;", )?; let java_class_name = JavaString::_try_from(class_name.clone(), self)?; let arg = JavaBoolean::new(true); let loader = self .jvm .as_ref() .ok_or("The jvm was unset".to_string())? .lock() .map_err(|_| "Could not lock mutex".to_string())? .class_loader() .clone() .unwrap(); let class_loader = LocalJavaObject::from_internal(loader.borrow(), self); let res = for_name .call(&[ java_class_name.as_arg(), arg.as_arg(), class_loader.as_arg(), ])? .ok_or("Class.forName() returned null".to_string())?; Ok(JavaClass::from_local( res.assign_env(self), #[cfg(feature = "type_check")] JavaType::new(class_name, true), )) } /// Find a class by its java class name /// /// Used by [`JavaEnv.find_class_by_java_name()`](crate::java::java_env::JavaEnv::find_class_by_java_name) /// and [`GlobalJavaClass.by_name()`](crate::java::java_object::GlobalJavaClass::by_name). pub fn find_global_class_by_java_name( &'a self, class_name: String, ) -> ResultType { crate::trace!("Resolving class '{}'", class_name); let class = self.get_java_lang_class()?; let for_name = class.get_static_object_method( "forName", "(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;", )?; let java_class_name = JavaString::_try_from(class_name.clone(), self)?; let arg = JavaBoolean::new(true); let loader = self .jvm .as_ref() .ok_or("The jvm was unset".to_string())? .lock() .map_err(|_| "Could not lock mutex".to_string())? .class_loader() .clone() .unwrap(); let class_loader = LocalJavaObject::from_internal(loader.borrow(), self); let cls = GlobalJavaClass::try_from_local( for_name .call(&[ java_class_name.as_arg(), arg.as_arg(), class_loader.as_arg(), ])? .ok_or("Class.forName() returned null".to_string())?, #[cfg(feature = "type_check")] JavaType::new(class_name, true), )?; Ok(cls) } pub fn get_system_class_loader(&self) -> ResultType { let class = self.find_class("java/lang/ClassLoader", true)?; let get_system_class_loader = class.get_static_object_method("getSystemClassLoader", "()Ljava/lang/ClassLoader;")?; let loader = get_system_class_loader .call(&[])? .ok_or("ClassLoader.getSystemClassLoader() returned null".to_string())?; GlobalJavaObject::try_from(loader) } pub fn get_method_id( &self, class: &'a JavaClass<'a>, method_name: &str, signature: &str, ) -> ResultType> { self.get_method_id_with_errors(class, method_name, signature, true) } pub fn get_method_id_with_errors( &self, class: &'a JavaClass<'a>, method_name: &str, signature: &str, resolve_errors: bool, ) -> ResultType> { crate::trace!("Getting method id for {}{}", method_name, signature); let method_name_str = CString::new(method_name)?; let signature_str = CString::new(signature)?; let method = unsafe { self.methods.GetMethodID.unwrap()( self.env, class.class(), method_name_str.as_ptr(), signature_str.as_ptr(), ) }; if self.is_err() || method.is_null() { Err(self.get_last_error( file!(), line!(), resolve_errors, format!("Could not find method '{}{}'", method_name, signature).as_str(), )?) } else { Ok(JavaMethod::new( method, class, JavaType::from_method_return_type(signature)?, false, #[cfg(feature = "type_check")] Signature::from_jni(signature)?, #[cfg(feature = "type_check")] method_name.to_string(), )) } } pub fn get_static_method_id( &self, class: &'a JavaClass<'a>, method_name: &str, signature: &str, ) -> ResultType> { crate::trace!("Getting static method id for {}{}", method_name, signature); let method_name_str = CString::new(method_name)?; let signature_str = CString::new(signature)?; let method = unsafe { self.methods.GetStaticMethodID.unwrap()( self.env, class.class(), method_name_str.as_ptr(), signature_str.as_ptr(), ) }; if self.is_err() || method.is_null() { Err(self.get_last_error( file!(), line!(), true, format!("Could not find method '{}'", method_name).as_str(), )?) } else { Ok(JavaMethod::new( method, class, JavaType::from_method_return_type(signature)?, true, #[cfg(feature = "type_check")] Signature::from_jni(signature)?, #[cfg(feature = "type_check")] method_name.to_string(), )) } } unsafe fn convert_args( &self, args: JavaArgs, #[cfg(feature = "type_check")] signature: &Signature, ) -> ResultType> { #[cfg(feature = "type_check")] if !signature.matches(&args) { Err(format!( "The arguments do not match the method signature: ({}) != {}", args.iter() .map(|a| a.get_type().to_string()) .collect::>() .join(", "), signature ) .into()) } else { Ok(args.iter().map(|arg| arg.to_java_value().value()).collect()) } #[cfg(not(feature = "type_check"))] Ok(args.iter().map(|arg| arg.to_java_value().value()).collect()) } pub fn call_object_method( &'a self, object: JavaObject<'_>, method: &JavaMethod<'_>, args: JavaArgs, ) -> ResultType>> { self.call_object_method_with_errors(object, method, args, true) } fn return_method_object( &'a self, obj: sys::jobject, _method: &JavaMethod<'_>, ) -> ResultType>> { Ok(obj.is_null().not().then(|| { LocalJavaObject::new( obj, self, #[cfg(feature = "type_check")] _method.get_signature().get_return_type().clone(), ) })) } pub fn call_object_method_with_errors( &'a self, object: JavaObject<'_>, method: &JavaMethod<'_>, args: JavaArgs<'_>, resolve_errors: bool, ) -> ResultType>> { #[cfg(feature = "log")] crate::trace!( "Calling object method {} with {} args", method.get_java_signature(), args.len() ); let obj = unsafe { let args = self.convert_args( args, #[cfg(feature = "type_check")] method.get_signature(), )?; self.methods.CallObjectMethodA.unwrap()( self.env, object.get_raw(), method.id(), args.as_ptr(), ) }; if self.is_err() { #[cfg(feature = "log")] log::debug!("Method {} threw an error", method.get_java_signature()); Err(self.get_last_error( file!(), line!(), resolve_errors, "CallObjectMethodA failed", )?) } else { self.return_method_object(obj, method) } } pub fn call_static_object_method( &'a self, class: &JavaClass<'_>, method: &JavaMethod<'_>, args: JavaArgs<'_>, ) -> ResultType>> { #[cfg(feature = "log")] crate::trace!( "Calling static object method {} with {} args", method.get_java_signature(), args.len() ); let obj = unsafe { let args = self.convert_args( args, #[cfg(feature = "type_check")] method.get_signature(), )?; self.methods.CallStaticObjectMethodA.unwrap()( self.env, class.class(), method.id(), args.as_ptr(), ) }; if self.is_err() { #[cfg(feature = "log")] log::debug!("Method {} threw an error", method.get_java_signature()); Err(self.get_last_error(file!(), line!(), true, "CallStaticObjectMethod failed")?) } else { self.return_method_object(obj, method) } } define_call_methods!( call_int_method, call_static_int_method, CallIntMethodA, CallStaticIntMethodA, i32, r, r ); define_call_methods!( call_long_method, call_static_long_method, CallLongMethodA, CallStaticLongMethodA, i64, r, r ); define_call_methods!( call_float_method, call_static_float_method, CallFloatMethodA, CallStaticFloatMethodA, f32, r, r ); define_call_methods!( call_boolean_method, call_static_boolean_method, CallBooleanMethodA, CallStaticBooleanMethodA, bool, r, r != 0 ); define_call_methods!( call_byte_method, call_static_byte_method, CallByteMethodA, CallStaticByteMethodA, i8, r, r ); define_call_methods!( call_char_method, call_static_char_method, CallCharMethodA, CallStaticCharMethodA, u16, r, r ); define_call_methods!( call_short_method, call_static_short_method, CallShortMethodA, CallStaticShortMethodA, i16, r, r ); define_call_methods!( call_double_method, call_static_double_method, CallDoubleMethodA, CallStaticDoubleMethodA, f64, r, r ); define_call_methods!( call_void_method, call_static_void_method, CallVoidMethodA, CallStaticVoidMethodA, (), r, r ); pub fn get_field_id( &'a self, class: &'a JavaClass<'a>, name: String, signature: JavaType, is_static: bool, ) -> ResultType> { #[cfg(feature = "log")] crate::trace!("Getting field {} with signature {}", name, signature); let field_name = CString::new(name.clone())?; let field_signature = CString::new(signature.to_jni_type())?; let field = unsafe { if is_static { self.methods.GetStaticFieldID.unwrap()( self.env, class.class(), field_name.as_ptr(), field_signature.as_ptr(), ) } else { self.methods.GetFieldID.unwrap()( self.env, class.class(), field_name.as_ptr(), field_signature.as_ptr(), ) } }; if self.is_err() || field.is_null() { Err(self.get_last_error( file!(), line!(), true, format!("Could not find field '{}'", name).as_str(), )?) } else { Ok(unsafe { JavaField::new(field, signature, class, is_static) }) } } fn return_field_object( &'a self, res: sys::jobject, _field: &T, alt_text: &'static str, ) -> ResultType>> { if self.is_err() { Err(self.get_last_error(file!(), line!(), true, alt_text)?) } else if res.is_null() { Ok(None) } else { Ok(Some(JavaObject::from(LocalJavaObject::new( res, self, #[cfg(feature = "type_check")] _field.get_signature_ref().clone(), )))) } } pub fn get_object_field( &'a self, field: &JavaObjectField<'_>, object: &JavaObject<'_>, ) -> ResultType>> { #[cfg(feature = "log")] crate::trace!("Getting object field {}", field.get_signature_ref()); let res = unsafe { self.methods.GetObjectField.unwrap()(self.env, object.get_raw(), field.id()) }; self.return_field_object(res, field, "GetObjectField failed") } pub fn set_object_field( &'a self, field: &JavaObjectField<'_>, object: &JavaObject<'_>, value: Option>, ) -> ResultType<()> { #[cfg(feature = "log")] crate::trace!("Setting object field {}", field.get_signature_ref()); unsafe { self.methods.SetObjectField.unwrap()( self.env, object.get_raw(), field.id(), value .as_ref() .map(|v| v.get_raw()) .unwrap_or(ptr::null_mut()), ); } if self.is_err() { Err(self.get_last_error(file!(), line!(), true, "SetObjectField failed")?) } else { Ok(()) } } pub fn get_static_object_field( &'a self, field: &StaticJavaObjectField, class: &JavaClass<'_>, ) -> ResultType>> { #[cfg(feature = "log")] crate::trace!("Getting static object field {}", field.get_signature()); let res = unsafe { self.methods.GetStaticObjectField.unwrap()(self.env, class.class(), field.id()) }; self.return_field_object(res, field, "GetStaticObjectField failed") } pub fn set_static_object_field( &'a self, field: &StaticJavaObjectField, class: &JavaClass<'_>, value: Option>, ) -> ResultType<()> { #[cfg(feature = "log")] crate::trace!("Setting static object field {}", field.get_signature()); unsafe { self.methods.SetStaticObjectField.unwrap()( self.env, class.class(), field.id(), value .as_ref() .map(|v| v.get_raw()) .unwrap_or(ptr::null_mut()), ); } if self.is_err() { Err(self.get_last_error( file!(), line!(), true, concat!(stringify!($static_setter), " failed"), )?) } else { Ok(()) } } define_field_methods!( get_int_field, set_int_field, get_static_int_field, set_static_int_field, JavaIntField, StaticJavaIntField, i32, GetIntField, SetIntField, GetStaticIntField, SetStaticIntField ); define_field_methods!( get_long_field, set_long_field, get_static_long_field, set_static_long_field, JavaLongField, StaticJavaLongField, i64, GetLongField, SetLongField, GetStaticLongField, SetStaticLongField ); define_field_methods!( get_float_field, set_float_field, get_static_float_field, set_static_float_field, JavaFloatField, StaticJavaFloatField, f32, GetFloatField, SetFloatField, GetStaticFloatField, SetStaticFloatField ); define_field_methods!( get_boolean_field, set_boolean_field, get_static_boolean_field, set_static_boolean_field, JavaBooleanField, StaticJavaBooleanField, u8, GetBooleanField, SetBooleanField, GetStaticBooleanField, SetStaticBooleanField ); define_field_methods!( get_byte_field, set_byte_field, get_static_byte_field, set_static_byte_field, JavaByteField, StaticJavaByteField, i8, GetByteField, SetByteField, GetStaticByteField, SetStaticByteField ); define_field_methods!( get_char_field, set_char_field, get_static_char_field, set_static_char_field, JavaCharField, StaticJavaCharField, u16, GetCharField, SetCharField, GetStaticCharField, SetStaticCharField ); define_field_methods!( get_short_field, set_short_field, get_static_short_field, set_static_short_field, JavaShortField, StaticJavaShortField, i16, GetShortField, SetShortField, GetStaticShortField, SetStaticShortField ); define_field_methods!( get_double_field, set_double_field, get_static_double_field, set_static_double_field, JavaDoubleField, StaticJavaDoubleField, f64, GetDoubleField, SetDoubleField, GetStaticDoubleField, SetStaticDoubleField ); pub fn get_object_array_element( &'a self, array: &'a JavaArray<'a>, index: i32, resolve_errors: bool, ) -> ResultType>> { let obj = unsafe { self.methods.GetObjectArrayElement.unwrap()(self.env, array.get_raw(), index) }; if self.is_err() { return Err(self.get_last_error( file!(), line!(), resolve_errors, "GetObjectArrayElement failed", )?); } if obj.is_null() { Ok(None) } else { Ok(Some(LocalJavaObject::new( obj, self, #[cfg(feature = "type_check")] array .get_signature() .inner() .ok_or("Array signature is not an array".to_string())? .lock() .unwrap() .clone(), ))) } } pub fn set_object_array_element( &'a self, array: &'a JavaArray<'a>, index: i32, element: Option>, ) -> ResultType<()> { unsafe { self.methods.SetObjectArrayElement.unwrap()( self.env, array.get_raw(), index, element .as_ref() .map(|e| e.get_raw()) .unwrap_or(ptr::null_mut()), ); } if self.is_err() { Err(self.get_last_error(file!(), line!(), true, "SetObjectArrayElement failed")?) } else { Ok(()) } } pub fn get_array_length(&self, array: sys::jobject) -> ResultType { assert_non_null!(array); let length = unsafe { self.methods.GetArrayLength.unwrap()(self.env, array) }; if self.is_err() { Err(self.get_last_error(file!(), line!(), true, "GetArrayLength failed")?) } else { Ok(length) } } pub fn create_object_array( &'_ self, class: &'a JavaClass<'a>, len: i32, ) -> ResultType> { let arr = unsafe { self.methods.NewObjectArray.unwrap()(self.env, len, class.class(), ptr::null_mut()) }; if self.is_err() || arr.is_null() { Err(self.get_last_error(file!(), line!(), true, "NewObjectArray failed")?) } else { Ok(JavaObjectArray::from(LocalJavaObject::new( arr, self, #[cfg(feature = "type_check")] JavaType::array(class.get_signature().clone()), ))) } } define_array_methods!( create_short_array, get_short_array_elements, *const i16, i16, JavaShortArray<'a>, NewShortArray, SetShortArrayRegion, GetShortArrayElements, ReleaseShortArrayElements, "short[]" ); define_array_methods!( create_int_array, get_int_array_elements, *const i32, i32, JavaIntArray<'a>, NewIntArray, SetIntArrayRegion, GetIntArrayElements, ReleaseIntArrayElements, "int[]" ); define_array_methods!( create_long_array, get_long_array_elements, *const i64, i64, JavaLongArray<'a>, NewLongArray, SetLongArrayRegion, GetLongArrayElements, ReleaseLongArrayElements, "long[]" ); define_array_methods!( create_float_array, get_float_array_elements, *const f32, f32, JavaFloatArray<'a>, NewFloatArray, SetFloatArrayRegion, GetFloatArrayElements, ReleaseFloatArrayElements, "float[]" ); define_array_methods!( create_double_array, get_double_array_elements, *const f64, f64, JavaDoubleArray<'a>, NewDoubleArray, SetDoubleArrayRegion, GetDoubleArrayElements, ReleaseDoubleArrayElements, "double[]" ); define_array_methods!( create_boolean_array, get_boolean_array_elements, *const u8, u8, JavaBooleanArray<'a>, NewBooleanArray, SetBooleanArrayRegion, GetBooleanArrayElements, ReleaseBooleanArrayElements, "boolean[]" ); define_array_methods!( create_byte_array, get_byte_array_elements, *const i8, i8, JavaByteArray<'a>, NewByteArray, SetByteArrayRegion, GetByteArrayElements, ReleaseByteArrayElements, "byte[]" ); define_array_methods!( create_char_array, get_char_array_elements, *const u16, u16, JavaCharArray<'a>, NewCharArray, SetCharArrayRegion, GetCharArrayElements, ReleaseCharArrayElements, "char[]" ); pub unsafe fn get_string_utf_chars(&self, string: sys::jstring) -> ResultType { assert_non_null!(string); let chars = self.methods.GetStringUTFChars.unwrap()(self.env, string, ptr::null_mut()); if self.is_err() || chars.is_null() { self.clear_err(); return Err(JNIError::from("GetStringUTFChars failed").into()); } let c_string = CStr::from_ptr(chars); let converted = c_string.to_str().map(|s| s.to_string()); self.methods.ReleaseStringUTFChars.unwrap()(self.env, string, chars); if self.is_err() { self.clear_err(); return Err(JNIError::from("ReleaseStringUTFChars failed").into()); } Ok(converted?) } pub fn string_to_java_string> + Display>( &'a self, string: T, ) -> ResultType> { crate::trace!("Converting '{}' to java string", string); let c_string = CString::new(string)?; let string = unsafe { self.methods.NewStringUTF.unwrap()(self.env, c_string.as_ptr()) }; if self.is_err() || string.is_null() { self.clear_err(); Err(JNIError::from("NewStringUTF failed").into()) } else { Ok(JavaString::new(self, string)) } } pub(in crate::java) fn get_java_vm(&self) -> ResultType { Ok(JavaVM::from_existing( self.jvm .as_ref() .ok_or("jvm was unset".to_string())? .clone(), )) } pub unsafe fn is_assignable_from( &self, sub: sys::jclass, sup: sys::jclass, ) -> ResultType { assert_non_null!(sub); assert_non_null!(sup); let result = self.methods.IsAssignableFrom.unwrap()(self.env, sub, sup); if self.is_err() { Err(self.get_last_error(file!(), line!(), true, "IsAssignableFrom failed")?) } else { Ok(result != 0) } } pub fn new_instance( &'a self, constructor: &JavaConstructor, args: JavaArgs, ) -> ResultType> { #[cfg(feature = "log")] crate::trace!( "Creating new instance of {} with {} args", constructor.get_signature(), args.len() ); let res = unsafe { let args = self.convert_args( args, #[cfg(feature = "type_check")] constructor.get_signature(), )?; self.methods.NewObjectA.unwrap()( self.env, constructor.class(), constructor.id(), args.as_ptr(), ) }; if self.is_err() || res.is_null() { Err(self.get_last_error(file!(), line!(), true, "NewObjectA failed")?) } else { Ok(LocalJavaObject::new( res, self, #[cfg(feature = "type_check")] constructor.get_class().get_signature().clone(), )) } } pub fn get_constructor( &'a self, class: &'a JavaClass<'a>, signature: &str, ) -> ResultType> { #[cfg(feature = "log")] crate::trace!( "Getting constructor {} for class {}", signature, class.get_signature() ); let id = unsafe { self.methods.GetMethodID.unwrap()( self.env, class.class(), CString::new("")?.as_ptr(), CString::new(signature)?.as_ptr(), ) }; if self.is_err() || id.is_null() { Err(self.get_last_error(file!(), line!(), true, "GetMethodID failed")?) } else { Ok(JavaConstructor::new( id, class, #[cfg(feature = "type_check")] Signature::from_jni(signature)?, )) } } pub fn append_class_path(&self, paths: Vec) -> ResultType<()> { let file_class = self.find_class("java/io/File", true)?; let file_constructor = file_class.get_constructor("(Ljava/lang/String;)V")?; let to_uri = file_class.get_object_method("toURI", "()Ljava/net/URI;")?; let uri_class = self.find_class("java/net/URI", true)?; let to_url = uri_class.get_object_method("toURL", "()Ljava/net/URL;")?; let url_class_loader = self.find_class("java/net/URLClassLoader", true)?; let class_loader_constructor = url_class_loader.get_constructor("([Ljava/net/URL;Ljava/lang/ClassLoader;)V")?; let url_class = self.find_class("java/net/URL", true)?; let mut urls = self.create_object_array(&url_class, paths.len() as i32)?; for i in 0..paths.len() { let java_path = self.string_to_java_string(paths.get(i).unwrap().clone())?; let file = self.new_instance(&file_constructor, &[java_path.as_arg()])?; let uri = to_uri .call(JavaObject::from(file), &[])? .ok_or("File.toURI returned null".to_string())?; let url = to_url .call(JavaObject::from(uri), &[])? .ok_or("URI.toURL returned null".to_string())?; urls.set(i as i32, Some(JavaObject::from(url)))?; } let old_class_loader = self .jvm .as_ref() .ok_or("The jvm was unset".to_string())? .lock() .map_err(|_| "Could not lock mutex".to_string())? .class_loader() .as_ref() .unwrap() .clone(); let class_loader = self.new_instance( &class_loader_constructor, &[urls.as_arg(), old_class_loader.as_arg()], )?; let res = GlobalJavaObject::try_from(class_loader)?; self.replace_class_loader(res) } pub fn replace_class_loader(&self, loader: GlobalJavaObject) -> ResultType<()> { self.jvm .as_ref() .ok_or("The jvm was unset".to_string())? .lock() .map_err(|_| "Could not lock mutex".to_string())? .set_class_loader(loader); Ok(()) } pub fn get_vm_ptr(&self) -> ResultType>> { Ok(self .jvm .as_ref() .ok_or("The jvm was unset".to_string())? .clone()) } } impl Drop for JavaEnvWrapper<'_> { fn drop(&mut self) { if self.jvm.is_none() { return; } if std::thread::current().id() != self.thread_id { panic!("JavaEnvWrapper was dropped from a different thread than it was created on, {:?} vs. {:?}", std::thread::current().id(), self.thread_id); } } }