android NDK 实用学习（五）-c++端调用java接口

1，阅读此文章前请阅读前面文章，以免阅读出现障碍；

android NDK 实用学习（一）-获取java端类及其类变量

android NDK 实用学习（二）-java端对象成员赋值和获取对象成员值

android NDK 实用学习（三）- java端类对象的构造及使用

android NDK 实用学习（四）-类缓存

2，java端类接口定义：

  public class RTKNativeManager {
       // 其他接口

      // 开给c++端的接口
      public static void notifyResolveResult(short id, TestSetData setData) {
          Log.d(TAG, "notifyResult start");

          boolean bb = setData.bData;
          int ii = setData.iData;
          String msg = String.format("get msg: %b-%d", bb, ii);
          Log.d(TAG, msg);

          Log.d(TAG, "notifyResult end!");
      }
 }

3, c++ 端获取类接口:

     // 获取类
     jclass jnativeMgr = NULL;
     jmethodID jnotifyKQResolveResult = NULL;

     // 获取类和方法
     jnativeMgr = env->FindClass("com/dasea/test/core/RTKNativeManager");

     jnotifyKQResolveResult = env->GetStaticMethodID(
             jnativeMgr, "notifyKQResolveResult", "(SLcom/dasea/test/core/TestSetData;)V");

3, 使用：

 void Jni_Call_Java_notifyResolveResult(short id){
     DEBUG_OUT(" WHAT QINGKUANG!!");

     JNIEnv* env = JniHelper::getEnv();
     if (NULL == env)
     {
         DEBUG_OUT(" ENV IS NULL!");
         return ;
     }

     // 获取类和方法
     jclass jnativeMgr = env->FindClass("com/dasea/test/core/RTKNativeManager");
     if (NULL == jnativeMgr)
     {
         DEBUG_OUT("Native mgr is NULL;!");
     }

     // 构造jni实例
    jclass jcSetDataMgr = env->FindClass("com/dasea/test/core/TestSetData");
     if(NULL == jcSetDataMgr){
         DEBUG_OUT("Not find class!");
         return ;
     }

     DEBUG_OUT("AllocObject object !");
     jmethodID initID = env->GetMethodID(jcSetDataMgr, "<init>", "()V");
     jobject jresult = env->NewObject(jcSetDataMgr, initID);

     if (NULL == jresult || env->ExceptionOccurred())
     {
         DEBUG_OUT("Construct object failed!");
         return ;
     }

     // 成员变量赋值，可以参考前面几篇文章

     DEBUG_OUT("CallStaticVoidMethod");

     // 调用静态方法
     env->CallStaticVoidMethod(jnativeMgr, jnotifyKQResolveResult , , jresult);
 }

4，上面代码中有Jnihelper类，代码如下：

 #ifndef __ANDROID_JNI_HELPER_H__
 #define __ANDROID_JNI_HELPER_H__

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

 typedef struct JniMethodInfo_ {
     JNIEnv * env;
     jclass classID;
     jmethodID methodID;
 } JniMethodInfo;

 class JniHelper {
 public:
     static void setJavaVM(JavaVM *javaVM);
     static JavaVM* getJavaVM();
     static JNIEnv* getEnv();

     static bool setClassLoaderFrom(jobject activityInstance);
     static bool getStaticMethodInfo(JniMethodInfo &methodinfo,
             const char *className, const char *methodName,
             const char *paramCode);
     static bool getMethodInfo(JniMethodInfo &methodinfo, const char *className,
             const char *methodName, const char *paramCode);

     static std::string jstring2string(jstring str);

     static jmethodID loadclassMethod_methodID;
     static jobject classloader;

 private:
     static JNIEnv* cacheEnv(JavaVM* jvm);

     static bool getMethodInfo_DefaultClassLoader(JniMethodInfo &methodinfo,
             const char *className, const char *methodName,
             const char *paramCode);

     static JavaVM* _psJavaVM;
 };

 #endif // __ANDROID_JNI_HELPER_H__

 /****************************************************************************
  Copyright (c) 2010-2012 cocos2d-x.org
  Copyright (c) 2013-2014 Chukong Technologies Inc.

  http://www.cocos2d-x.org

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  ****************************************************************************/
 #include "JniHelper.h"
 #include <string.h>
 #include <pthread.h>
 #include "CBasePara.h"

 static pthread_key_t g_key;

 jclass _getClassID(const char *className) {
     if (NULL == className) {
         return NULL;
     }

     JNIEnv* env = JniHelper::getEnv();

     jstring _jstrClassName = env->NewStringUTF(className);

 //    jclass _clazz = (jclass) env->CallObjectMethod(JniHelper::classloader,
 //                                                   JniHelper::loadclassMethod_methodID,
 //                                                   _jstrClassName);

     jclass _clazz = (jclass) env->FindClass(className);

     if (NULL == _clazz) {
         DEBUG_OUT("Classloader failed to find class of %s", className);
         env->ExceptionClear();
     }

     env->DeleteLocalRef(_jstrClassName);

     return _clazz;
 }

 JavaVM* JniHelper::_psJavaVM = NULL;
 jmethodID JniHelper::loadclassMethod_methodID = NULL;
 jobject JniHelper::classloader = NULL;

 JavaVM* JniHelper::getJavaVM() {
     pthread_t thisthread = pthread_self();
     //LOGD("JniHelper::getJavaVM(), pthread_self() = %ld", thisthread);
     return _psJavaVM;
 }

 void JniHelper::setJavaVM(JavaVM *javaVM) {
     pthread_t thisthread = pthread_self();
     //LOGD("JniHelper::setJavaVM(%p), pthread_self() = %ld", javaVM, thisthread);
     _psJavaVM = javaVM;

     pthread_key_create(&g_key, NULL);
 }

 JNIEnv* JniHelper::cacheEnv(JavaVM* jvm) {
     JNIEnv* _env = NULL;
     // get jni environment
     jint ret = jvm->GetEnv((void**) &_env, JNI_VERSION_1_4);

     switch (ret) {
     case JNI_OK:
         // Success!
         pthread_setspecific(g_key, _env);
         return _env;

     case JNI_EDETACHED:
         // Thread not attached

         // TODO : If calling AttachCurrentThread() on a native thread
         // must call DetachCurrentThread() in future.
         // see: http://developer.android.com/guide/practices/design/jni.html

         if (jvm->AttachCurrentThread(&_env, NULL) < ) {
             DEBUG_OUT(
                     "Failed to get the environment using AttachCurrentThread()");

             return NULL;
         } else {
             // Success : Attached and obtained JNIEnv!
             pthread_setspecific(g_key, _env);
             return _env;
         }

     case JNI_EVERSION:
         // Cannot recover from this error
         DEBUG_OUT("JNI interface version 1.4 not supported");
     default:
         DEBUG_OUT("Failed to get the environment using GetEnv()");
         return NULL;
     }
 }

 JNIEnv* JniHelper::getEnv() {
     JNIEnv *_env = (JNIEnv *) pthread_getspecific(g_key);
     if (_env == NULL)
         _env = JniHelper::cacheEnv(_psJavaVM);
     return _env;
 }

 bool JniHelper::setClassLoaderFrom(jobject activityinstance) {
     JniMethodInfo _getclassloaderMethod;
     if (!JniHelper::getMethodInfo_DefaultClassLoader(_getclassloaderMethod,
             "android/content/Context", "getClassLoader",
             "()Ljava/lang/ClassLoader;")) {
         return false;
     }

     jobject _c = JniHelper::getEnv()->CallObjectMethod(activityinstance,
             _getclassloaderMethod.methodID);

     if (NULL == _c) {
         return false;
     }

     JniMethodInfo _m;
     if (!JniHelper::getMethodInfo_DefaultClassLoader(_m,
             "java/lang/ClassLoader", "loadClass",
             "(Ljava/lang/String;)Ljava/lang/Class;")) {
         return false;
     }

     JniHelper::classloader = JniHelper::getEnv()->NewGlobalRef(_c);
     JniHelper::loadclassMethod_methodID = _m.methodID;

     return true;
 }

 bool JniHelper::getStaticMethodInfo(JniMethodInfo &methodinfo,
         const char *className, const char *methodName, const char *paramCode) {
     if ((NULL == className) || (NULL == methodName) || (NULL == paramCode)) {
         return false;
     }

     JNIEnv *env = JniHelper::getEnv();
     if (!env) {
         DEBUG_OUT("Failed to get JNIEnv");
         return false;
     }

     jclass classID = _getClassID(className);
     if (!classID) {
         DEBUG_OUT("Failed to find class %s", className);
         env->ExceptionClear();
         return false;
     }

     jmethodID methodID = env->GetStaticMethodID(classID, methodName, paramCode);
     if (!methodID) {
         DEBUG_OUT("Failed to find static method id of %s", methodName);
         env->ExceptionClear();
         return false;
     }

     methodinfo.classID = classID;
     methodinfo.env = env;
     methodinfo.methodID = methodID;
     return true;
 }

 bool JniHelper::getMethodInfo_DefaultClassLoader(JniMethodInfo &methodinfo,
         const char *className, const char *methodName, const char *paramCode) {
     if ((NULL == className) || (NULL == methodName) || (NULL == paramCode)) {
         return false;
     }

     JNIEnv *env = JniHelper::getEnv();
     if (!env) {
         return false;
     }

     jclass classID = env->FindClass(className);
     if (!classID) {
         DEBUG_OUT("Failed to find class %s", className);
         env->ExceptionClear();
         return false;
     }

     jmethodID methodID = env->GetMethodID(classID, methodName, paramCode);
     if (!methodID) {
         DEBUG_OUT("Failed to find method id of %s", methodName);
         env->ExceptionClear();
         return false;
     }

     methodinfo.classID = classID;
     methodinfo.env = env;
     methodinfo.methodID = methodID;

     return true;
 }

 bool JniHelper::getMethodInfo(JniMethodInfo &methodinfo, const char *className,
         const char *methodName, const char *paramCode) {
     if ((NULL == className) || (NULL == methodName) || (NULL == paramCode)) {
         return false;
     }

     JNIEnv *env = JniHelper::getEnv();
     if (!env) {
         return false;
     }

     jclass classID = _getClassID(className);
     if (!classID) {
         DEBUG_OUT("Failed to find class %s", className);
         env->ExceptionClear();
         return false;
     }

     jmethodID methodID = env->GetMethodID(classID, methodName, paramCode);
     if (!methodID) {
         DEBUG_OUT("Failed to find method id of %s", methodName);
         env->ExceptionClear();
         return false;
     }

     methodinfo.classID = classID;
     methodinfo.env = env;
     methodinfo.methodID = methodID;

     return true;
 }

 std::string JniHelper::jstring2string(jstring jstr) {
     if (jstr == NULL) {
         return "";
     }

     JNIEnv *env = JniHelper::getEnv();
     if (!env) {
         return NULL;
     }

     const char* chars = env->GetStringUTFChars(jstr, NULL);
     std::string ret(chars);
     env->ReleaseStringUTFChars(jstr, chars);

     return ret;
 }

5，在c++端定义JNI_OnLoad接口：

 jint JNI_OnLoad(JavaVM *vm, void *reserved) {
     JniHelper::setJavaVM(vm);

     return JNI_VERSION_1_4;
 }

6，注意：

如果使用c++端调用java端接口时，就需要通过JniHelper::getEnv()接口获取env。