JNI中调用Java函数

JNIEXPORT jstring JNICALL
Java_com_example_hellojni_HelloJni_stringFromJNI(JNIEnv *env, jobject thiz) {
  // ...
}

package com.example.hellojni
class HelloJni : AppCompatActivity() {
  // ...
  override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
    // ...
        binding.helloTextview.text = stringFromJNI()
    }
    
  external fun stringFromJNI(): String?
  companion object {
        init {
            System.loadLibrary("hello-jni")
        }
    }
}

// 动态注册
namespace android {

static jobject android_os_MemoryFile_open(JNIEnv* env, jobject clazz, jstring name, jint length) {
  // ...
  }
}

static const JNINativeMethod methods[] = {
    {"native_open",  "(Ljava/lang/String;I)Ljava/io/FileDescriptor;", (void*)android_os_MemoryFile_open},
    {"native_mmap",  "(Ljava/io/FileDescriptor;II)I", (void*)android_os_MemoryFile_mmap},
    {"native_munmap", "(II)V", (void*)android_os_MemoryFile_munmap},
    {"native_close", "(Ljava/io/FileDescriptor;)V", (void*)android_os_MemoryFile_close},
    {"native_read",  "(Ljava/io/FileDescriptor;I[BIIIZ)I", (void*)android_os_MemoryFile_read},
    {"native_write", "(Ljava/io/FileDescriptor;I[BIIIZ)V", (void*)android_os_MemoryFile_write},
    {"native_pin",   "(Ljava/io/FileDescriptor;Z)V", (void*)android_os_MemoryFile_pin},
    {"native_get_size", "(Ljava/io/FileDescriptor;)I",
            (void*)android_os_MemoryFile_get_size}
};

int AndroidRuntime::registerNativeMethods(JNIEnv* env,
    const char* className, const JNINativeMethod* gMethods, int numMethods)

package com.my.hawk.jni2;
 
import androidx.appcompat.app.AppCompatActivity;
 
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
 
import static java.lang.String.format;
 
public class MainActivity extends AppCompatActivity {
 
    TextView tv;
    // Used to load the 'native-lib' library on application startup.
    static {
        System.loadLibrary("native-lib");
    }
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        // Example of a call to a native method
        tv = findViewById(R.id.sample_text);
        tv.setText(stringFromJNI());
 
        nativeInitilize();
 
        Button startBt = findViewById(R.id.button);
        startBt.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                nativeThreadStart();
            }
        });
 
        Button stopBt = findViewById(R.id.button2);
        stopBt.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                nativeThreadStop();
            }
        });
    }
 
    public void onNativeCb(int count) {
        Log.d("Native", "onNativeCb count=" + count);
//        TextView tv = findViewById(R.id.sample_text);
//        tv.setText(format("%s%d", stringFromJNI(), count));
        tv.post(new Runnable() {
            @Override
            public void run() {
                tv.setText(format("%s%d", stringFromJNI(), count));
            }
        });
    }
 
    /**
     * A native method that is implemented by the 'native-lib' native library,
     * which is packaged with this application.
     */
    public native String stringFromJNI();
 
    public native void nativeInitilize();
    public native void nativeThreadStart();
    public native void nativeThreadStop();
}

#include <jni.h>
#include <string>
#include <sstream>
#include <android/log.h>
#include <unistd.h>
 
JavaVM *gJavaVm;
jobject gJaveObj;
static volatile int gIsThreadExit = 0;
 
#define LOG(...) __android_log_print(ANDROID_LOG_DEBUG, "Native", __VA_ARGS__)
 
static const char *classPath = "com/my/hawk/jni2/MainActivity";
 
extern "C" JNIEXPORT jstring JNICALL
Java_com_my_hawk_jni2_MainActivity_stringFromJNI(
        JNIEnv* env,
        jobject /* this */) {
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}
 
extern "C"
JNIEXPORT void JNICALL
Java_com_my_hawk_jni2_MainActivity_nativeInitilize(JNIEnv *env, jobject thiz) {
    env->GetJavaVM(&gJavaVm);
    gJaveObj = env->NewGlobalRef(thiz);
}
 
static void* native_thread_exec(void *arg) {
    JNIEnv *env;
    gJavaVm->AttachCurrentThread(&env, nullptr);
 
//    jclass javaClass = env->FindClass(classPath);
    jclass javaClass = env->GetObjectClass(gJaveObj);
    if (javaClass == nullptr) {
        LOG("Fail to find javaClass");
        return nullptr;
    }
 
    jmethodID javaCallback = env->GetMethodID(javaClass, "onNativeCb", "(I)V");
    if (javaCallback == nullptr) {
        LOG("Fail to find method onNativeCb");
        return nullptr;
    }
 
    LOG("native_thread_exec loop enter");
 
    int count = 0;
    while (!gIsThreadExit) {
        env->CallVoidMethod(gJaveObj, javaCallback, count++);
        sleep(1);
    }
    gJavaVm->DestroyJavaVM();
    LOG("native_thread_exec loop leave");
 
    return nullptr;
}
 
extern "C"
JNIEXPORT void JNICALL
Java_com_my_hawk_jni2_MainActivity_nativeThreadStart(JNIEnv *env, jobject thiz) {
    gIsThreadExit = 0;
    pthread_t threadId;
    if (pthread_create(&threadId, nullptr, native_thread_exec, nullptr) != 0) {
        LOG("native_thread_start pthread_create fail!");
        return;
    }
    LOG("native_thread_start success");
}
 
extern "C"
JNIEXPORT void JNICALL
Java_com_my_hawk_jni2_MainActivity_nativeThreadStop(JNIEnv *env, jobject thiz) {
    gIsThreadExit = 1;
    LOG("native_thread_stop success");
}

    env->GetJavaVM(&gJavaVm);
    gJaveObj = env->NewGlobalRef(thiz);