JNI

graph LR
JavaVM-->singlePerProcess
JNIEnv-->singlePerThread

class Cls1 { 
  int g(int i); 
  native int g(double d); 
}

package pkg;  

class Cls { 
     native double f(int i, String s); 
     ... 
} 

//The C function with the long mangled name Java_pkg_Cls_f_ILjava_lang_String_2 implements native method f:
//Code Example 2-1 Implementing a Native Method Using C

jdouble Java_pkg_Cls_f__ILjava_lang_String_2 ( 
     JNIEnv *env,        /* interface pointer */ 
     jobject obj,        /* "this" pointer */ 
     jint i,             /* argument #1 */ 
     jstring s)          /* argument #2 */ 

{ 
     /* Obtain a C-copy of the Java string */ 
     const char *str = (*env)->GetStringUTFChars(env, s, 0); 

     /* process the string */ 
     ... 

     /* Now we are done with str */ 
     (*env)->ReleaseStringUTFChars(env, s, str); 
     return ... 
}

extern "C" JNIEXPORT JNICALL jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env;
    if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) != JNI_OK) {
        return -1;
    }
}

static jmethodID g_callbackOnContentChange = nullptr;

    g_cls = reinterpret_cast<jclass>(env->NewGlobalRef(instance));
    if (!g_cls) {
        MMKVError("fail to create global reference for %s", clsName);
        return -3;
    }

    g_callbackOnContentChange =
        env->GetStaticMethodID(g_cls, "onContentChangedByOuterProcess", "(Ljava/lang/String;)V");
    if (!g_callbackOnContentChange) {
        MMKVError("fail to get method id for onContentChangedByOuterProcess()");
    
currentEnv->CallStaticVoidMethod(g_cls, g_callbackOnContentChange, str);

//libnativehelper/include/nativehelper/JNIHelp.h
inline int jniThrowRuntimeException(JNIEnv* env, const char* msg) {
    return jniThrowRuntimeException(&env->functions, msg);
}

//libnativehelper/JNIHelp.c
int jniThrowRuntimeException(JNIEnv* env, const char* msg) {
    return jniThrowException(env, "java/lang/RuntimeException", msg);
}

int jniThrowException(JNIEnv* env, const char* className, const char* message) {
    DiscardPendingException(env, className);
    jclass exceptionClass = (*env)->FindClass(env, className);
    if (exceptionClass == NULL) {
        ALOGE("Unable to find exception class %s", className); /* ClassNotFoundException now pending */
        return -1;
    }
    int status = 0;
    if ((*env)->ThrowNew(env, exceptionClass, message) != JNI_OK) {
        ALOGE("Failed throwing '%s' '%s'", className, message);
        /* an exception, most likely OOM, will now be pending */
        status = -1;
    }
    (*env)->DeleteLocalRef(env, exceptionClass);
    return status;
}

//art/runtime/jni/jni_internal.cc
  static jint ThrowNew(JNIEnv* env, jclass c, const char* msg) {
    return ThrowNewException(env, c, msg, nullptr);
  }

int ThrowNewException(JNIEnv* env, jclass exception_class, const char* msg, jobject cause)
  REQUIRES(!Locks::mutator_lock_) {
  jmethodID mid = env->GetMethodID(exception_class, "<init>", signature);
  ScopedLocalRef<jthrowable> exception(
      env, reinterpret_cast<jthrowable>(env->NewObjectA(exception_class, mid, args)));
  ScopedObjectAccess soa(env);
  soa.Self()->SetException(soa.Decodemirror::Throwable(exception.get()));
}


//art/runtime/thread.cc
void Thread::SetException(ObjPtrmirror::Throwable new_exception) {
  CHECK(new_exception != nullptr);
  // TODO: DCHECK(!IsExceptionPending());
  tlsPtr_.exception = new_exception.Ptr();
}