1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
use super::*; /// FFI: Use **Argument\<java::lang::Object\>** instead of jobject. This represents a (null?) function argument. /// /// Unlike most Java reference types from this library, this *can* be null. /// /// FFI safe where a jobject is safe, assuming you match your types correctly. Using the wrong type may result in /// soundness issues, but at least on Android mostly seems to just result in JNI aborting execution for the current /// process when calling methods on an instance of the wrong type. #[repr(transparent)] pub struct Argument<Class: AsValidJObjectAndEnv> { object: jobject, _class: PhantomData<Class>, } impl<Class: AsValidJObjectAndEnv> Argument<Class> { /// **unsafe**: There's no guarantee the jobject being passed is valid or null, nor any means of checking it. pub unsafe fn from_unchecked(object: jobject) -> Self { Self { object, _class: PhantomData } } /// **unsafe**: This assumes the argument belongs to the given Env/VM, which is technically unsound. However, the /// intended use case of immediately converting any Argument s into ArgumentRef s at the start of a JNI callback, /// where Java directly invoked your function with an Env + arguments, is sound. pub unsafe fn with_unchecked<'env>(&'env self, env: &'env Env) -> Option<ArgumentRef<'env, Class>> { if self.object.is_null() { None } else { let env = env.as_jni_env(); Some(ArgumentRef { oae: ObjectAndEnv { object: self.object, env, }, _env: PhantomData, _class: PhantomData, }) } } } /// A [Local](https://www.ibm.com/support/knowledgecenter/en/SSYKE2_8.0.0/com.ibm.java.vm.80.doc/docs/jni_refs.html), /// non-null, reference to a Java object (+ &Env). /// /// Much like Local, the inclusion of an Env means this cannot be stored statically or shared between threads. /// /// **Not FFI Safe:** #\[repr(rust)\], and exact layout is likely to change - depending on exact features used - in the /// future. Specifically, on Android, since we're guaranteed to only have a single ambient VM, we can likely store the /// \*const JNIEnv in thread local storage instead of lugging it around in every Local. Of course, there's no /// guarantee that's actually an *optimization*... pub type ArgumentRef<'env, Class> = Ref<'env, Class>;