rucaja 0.2.0

Rust Calls Java - via JNI
Documentation 
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

extern crate jni_sys;
extern crate rucaja;

use jni_sys::{JNI_FALSE, JNI_TRUE};
use rucaja::{jvalue_from_jboolean, jvalue_from_jobject, Jvm, JvmClass, JvmMethod};
use std::ptr::null;


/// Calls a static Java method that returns a Java `bool`.
fn call_static_boolean_method(jvm: &Jvm, class: &JvmClass) {

    // The arguments for the Java methods.
    let jvm_method_arguments = [
        JNI_FALSE,
        JNI_TRUE,
    ];

    unsafe {

        // Get the Java method.
        let jvm_method = jvm.get_static_method(
            &class,
            "static_method_that_returns_a_boolean",
            "(Z)Z"
        ).expect("Could not find JVM method");

        // Iterate over the Java method arguments.
        for jvm_method_argument in &jvm_method_arguments {

            let args = vec![jvalue_from_jboolean(*jvm_method_argument)];

            // Call the java method with the current argument.
            let result = jvm.call_static_boolean_method(&class, &jvm_method, args.as_ptr());

            // Print the result of the Java call.
            println!("`call_static_boolean_method({})`; {:?}", jvm_method_argument, result);
        }
    }
}

/// Calls static Java methods that return a Java object.
fn call_static_object_method(jvm: &Jvm, class: &JvmClass, println: &JvmMethod) {

    // The names of Java methods to call.
    let jvm_method_names = [
        "static_method_that_returns_a_string",

        // An attempted access to an interned `String` gives `java.security.AccessControlContext@0`.
        "static_method_that_returns_an_interned_string"
    ];

    unsafe {
        // Iterate over the Java method names.
        for jvm_method_name in &jvm_method_names {

                // Get the current Java method.
                let jvm_method = jvm.get_static_method(
                    &class,
                    jvm_method_name,
                    "()Ljava/lang/String;"
                ).expect("Could not find JVM method");

                // Call the Java method.
                let result = jvm.call_static_object_method(&class, &jvm_method, null());
                println!("`call_static_object_method(): `{}()` returned {:?}`", jvm_method_name, result);

                // Print the Java result object via a Java method.
                println!("Print the JVM object:");
                let args = vec![jvalue_from_jobject(result)];
                jvm.call_static_void_method(&class, &println, args.as_ptr());
            }
    }
}

/// Calls a static void Java method.
fn call_static_void_method(jvm: &Jvm, class: &JvmClass) {

    unsafe {

        // Get the Java method.
        let jvm_method = jvm.get_static_method(
            &class,
            "static_void_method",
            "()V"
        ).expect("Could not find JVM method");

        jvm.call_static_void_method(&class, &jvm_method, null());
        println!("`call_static_void_method()`");
    }
}

fn main() {

    // JVM options.
    let jvm_options = [
        //"-verbose:gc",
        //"-verbose:jni",
        //"-Xcheck:jni",
    ];

    unsafe {
        // Instantiate the embedded JVM.
        let jvm = Jvm::new(&jvm_options);

        // Get the Java class `Test` from `Test.java`.
        let class = jvm.get_class("Test").expect("Could not find JVM class");

        // Get the `println()` Java wrapper method for debugging the JVM objects.
        let println = jvm.get_static_method(
            &class,
            "println",
            "(Ljava/lang/Object;)V"
        ).expect("Could not find JVM method");

        // Call some Java methods.
        call_static_boolean_method(&jvm, &class);
        call_static_object_method(&jvm, &class, &println);
        call_static_void_method(&jvm, &class);
    }
}