问C++对C++回调的Java回调

EN

package foo;
import foo.Functor;

//this is just what we want to call from C++
//for demonstration, expect return type int
public class Bar
{
    public static void run(long addr) {
        Functor F = new Functor(addr);

        //synchronously here, just to prove the concept
        F.run(1,2);
    }
}

//we need to write this for every signature of a callback function
//we'll do this as a void foo(int,int), just to demonstrate
//if someone knows how to write this in a general (yet JNI-compatible) way,
//keeping in mind what we are doing in the non-Java part, feel free to tell me
public class Functor
{
    static {
        System.loadLibrary("functors");
    }
    public native void runFunctor(long addr,int a,int b);

    long address;

    public Functor(long addr)
    {
    address = addr;
    }

    public void run(int a, int b) {
        runFunctor(address,a,b);
    }
}

#include <functional>
#include "include/foo_Functor.h"

JNIEXPORT void JNICALL Java_foo_Functor_runFunctor
  (JNIEnv *env, jobject obj, jlong address, jint a, jint b)
{
    //make sure long is the right size
    static_assert(sizeof(jlong)==sizeof(std::function<void(int,int)>*),"Pointer size doesn't match");

    //this is ugly, if someone has a better idea...
    (*reinterpret_cast<std::function<void(int,int)>*>(address))(static_cast<int>(a),static_cast<int>(b));
}

#include <iostream>
#include <string>
#include <jni.h>
#include <functional>

int main()
{
    //this is from some tutorial, nothing special
    JavaVM *jvm;
    JNIEnv *env;
    JavaVMInitArgs vm_args;
   JavaVMOption* options = new JavaVMOption[1];  
    options[0].optionString = "-Djava.class.path=."; //this is actually annoying, JNI has this as char* without const, resulting in a warning since this is illegal in C++ (from C++11)
    vm_args.version = JNI_VERSION_1_6;   
    vm_args.nOptions = 1;      
    vm_args.options = options;
    vm_args.ignoreUnrecognized = false;  

    jint rc = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);
    delete[] options; 

    if (rc != JNI_OK)
        return EXIT_FAILURE;


    jclass cls = env->FindClass("foo/Bar");
    jmethodID mid = env->GetStaticMethodID(cls, "run", "(J)V");

    //the main drawback of this approach is that this std::function object must never go out of scope as long as the callback could be fired
    std::function<void(int,int)> F([](int a, int b){std::cout << a+b << std::endl;});

    //this is a brutal cast, is there any better option?
    long address = reinterpret_cast<long>(&F);
    env->CallStaticVoidMethod(cls,mid,static_cast<jlong>(address));


    if (env->ExceptionOccurred())
        env->ExceptionDescribe();
    jvm->DestroyJavaVM();
    return EXIT_SUCCESS;
}