need help invoking callback interface

[therealkenc]

I am getting my feed wet with jni-bind but could not figure out the correct way to invoke a Java interface passed as an argument.

Java setup. I do a new GreetingCallback() {...} and call JniTest.greet() elsewhere.

package com.example.jnicalc;

public class JniTest {
    public interface GreetingCallback {
        public void invoke(String greeting);
    }

    public static native void greet(String msg, GreetingCallback cb);

    public void hello(String msg) {
        System.out.println("hallo callback: " + msg);
    }
    // ...
}

C++ side

JNIEXPORT void JNICALL Java_com_example_jnicalc_JniTest_greet(
    JNIEnv* penv, jclass, jstring msg, jobject jcallback)
{
    static constexpr jni::Class JniTest{ "com/example/jnicalc/JniTest",
        jni::Method{ "hello", jni::Return<void>{}, jni::Params<jstring>{} } };
    static constexpr jni::Class GreetingCallback{ "com/example/jnicalc/JniTest/GreetingCallback",
        jni::Method{ "invoke", jni::Return<void>{}, jni::Params<jstring>{} } };

    std::string_view prefix = jni::LocalString(msg).Pin().ToString();
    std::string greeting = std::string(prefix) + ", with stuff"s;
    jni::LocalString new_msg{greeting};

    jni::LocalObject<GreetingCallback> callback{jcallback};
    auto name = callback.name_;
    // name is: com/example/jnicalc/JniTest/GreetingCallback
    std::cout << "name is: " << name << std::endl;

    //callback("invoke", new_msg);  // <-- this crashes
    
    // old school invoke of the callback interface works
    jstring jnew_msg{new_msg};
    auto cb_class = jni::JniHelper::GetObjectClass(jcallback);
    auto method = jni::JniHelper::GetMethodID(cb_class, "invoke", "(Ljava/lang/String;)V");
    jni::JniEnv::GetEnv()->CallVoidMethod(jcallback, method, jnew_msg);

    // creating a new local object and passing that works
    jni::LocalObject<JniTest> hello{};
    hello("hello", new_msg);
}

I assume that usage of jni::LocalObject<GreetingCallback> which is commented out is plain incorrect. Invoking the callback with CallVoidMethod() works, but I am guessing there is a more straightforward way to do this.

Any help or suggestions very much appreciated.

[therealkenc]

Slightly modified with a GlobalObject and a thread.

static constexpr jni::Class GreetingCallback{ "com/example/jnicalc/JniTest/GreetingCallback",
    jni::Method{ "invoke", jni::Return<void>{}, jni::Params<jstring>{} } };

extern "C" JNIEXPORT void JNICALL Java_com_example_jnicalc_JniTest_greet(
    JNIEnv*, jclass, jstring jmsg, jobject jcallback)
{
    const auto toString = [](jstring s) {
        return std::string(jni::LocalString{ s }.Pin().ToString());
    };
    const auto greeting = toString(jmsg) + ", with stuff"s;
    jni::GlobalObject<GreetingCallback> cb{ jni::PromoteToGlobal{}, jcallback };

    std::thread([greeting, cb = std::move(cb)]() mutable {
        jni::ThreadGuard guard = jvm->BuildThreadGuard();
        std::this_thread::sleep_for(5s);
        jni::LocalString lgreet{ greeting };

        // no joy, segfaults
        // cb("invoke", lgreet);

        // plausible...
        auto cb_class = jni::JniHelper::GetObjectClass((jobject)cb);
        auto method = jni::JniHelper::GetMethodID(cb_class, "invoke", "(Ljava/lang/String;)V");
        jni::JniEnv::GetEnv()->CallVoidMethod((jobject)cb, method, (jstring)lgreet);
    }).detach();
}

It was nonobv to me how to get at the jstring and jobject from the LocalString and GlobalObject. I hope those casts are the correct intent behind making LocalString::operator jstring explicit here.

I could not find a way to cooerce the signature of a jni:Class method (f.e. "(Ljava/lang/String;)V"), despite best efforts, even though the plumbing is there.

If there is a way to do this "properly" without reaching for jni::JniHelper it would be good to know, but I could not find a test case that calls a callback interface.