JNI实现JAVA和C++互相调用

SDK.h

 #ifndef SDK_H
 #define SDK_H
 
 #include "AsyncProxy.h"
 #include "Module.h"
 #include <map>
 #include <vector>
 #include <string>
 using std::map;
 using std::vector;
 using std::string;
 
 class SDK
 {
 private:
     vector<Module*> m_modules;
     AsyncProxy* mp_asyncProxy;
     map<string,Method*> m_methodIndex;
 private:
     Method* checkMethod(string methodName, map<std::string, std::string> &params);
     void init();
 public:
     SDK();
     SDK(CallBackFun* p_exceptionFun);
     ~SDK();
     void addModule(Module* p_module);
     string request(string methodName, map<string,string>& params);
     void requestAsync(string methodName, map<string, string> &params, CallBackFun* p_callBack = NULL);
 };
 
 #endif

CallBackFun.h

 class CallBackFun
 {
 public:
     virtual ~CallBackFun(){}
     virtual void callBack(string& result){SDK_DEBUG("%s",result.c_str());}
 };

main.cpp

#include <string.h>
#include <jni.h>
#include "core/SDK.h"
 
static JavaVM* p_vm = NULL;
 
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
{
    p_vm = vm;
    return JNI_VERSION_1_6;
}
 
class JavaCallBackFun:public CallBackFun
{
private:
    jobject m_object;
    jstring m_method;
    static const char* m_signature;
    bool m_destroy;
public:
    JavaCallBackFun( JNIEnv* env,jobject object,jstring method,bool destroy)
    {
        m_object = env->NewGlobalRef(object);
        m_method = (jstring)env->NewGlobalRef(method);
        m_destroy = destroy;
    }
 
    ~JavaCallBackFun()
    {
        if(m_destroy == false)
        {
            JNIEnv* env;
            p_vm->AttachCurrentThread(&env, NULL);
            env->DeleteGlobalRef(m_object);
            env->DeleteGlobalRef(m_method);
        }
    }
 
    void callBack(string& result)
    {
        JNIEnv* env;
        p_vm->AttachCurrentThread(&env, NULL);
        jstring jresult = env->NewStringUTF(result.c_str());
        const char* methodStr = env->GetStringUTFChars(m_method, );
        jclass clazz = env->GetObjectClass(m_object);
        jmethodID  methodID = env -> GetMethodID(clazz,methodStr,m_signature);
        env -> CallVoidMethod(m_object,methodID,jresult);
        env -> ReleaseStringUTFChars(m_method,methodStr);
        if(m_destroy == true)
        {
            env->DeleteGlobalRef(m_object);
            env->DeleteGlobalRef(m_method);
        }
    }
};
const char* JavaCallBackFun::m_signature = "(Ljava/lang/String;)V";
 
extern "C" {
    JNIEXPORT jlong JNICALL Java_com_pptv_sdk_CommonSDK_initSDKNative( JNIEnv* env,jobject thiz,jobject callBackObj,jstring exceptionFun);
    JNIEXPORT void JNICALL Java_com_pptv_sdk_CommonSDK_cleanSDKNative( JNIEnv* env,jobject thiz,jlong sdkptr);
    JNIEXPORT jstring JNICALL Java_com_pptv_sdk_CommonSDK_requestNative( JNIEnv* env,jobject thiz,jlong sdkptr,jstring methodName,\
                                                                         jobjectArray paramKeys,jobjectArray paramValues);
    JNIEXPORT void JNICALL Java_com_pptv_sdk_CommonSDK_requestAsyncNative( JNIEnv* env,jobject thiz,jlong sdkptr,jstring methodName,\
                                                jobjectArray paramKeys,jobjectArray paramValues,jobject callBackObj,jstring callBackMethod);
};
 
JNIEXPORT jlong JNICALL Java_com_pptv_sdk_CommonSDK_initSDKNative( JNIEnv* env,jobject thiz,jobject callBackObj,jstring exceptionFun)
{
    JavaCallBackFun* p_callBack = new JavaCallBackFun(env,callBackObj,exceptionFun,false);
    return (jlong)new SDK(p_callBack);
}
 
JNIEXPORT void JNICALL Java_com_pptv_sdk_CommonSDK_cleanSDKNative( JNIEnv* env,jobject thiz,jlong sdkptr)
{
    SDK* p_sdk = (SDK*)sdkptr;
    delete p_sdk;
}
 
JNIEXPORT jstring JNICALL Java_com_pptv_sdk_CommonSDK_requestNative( JNIEnv* env,jobject thiz,jlong sdkptr,jstring methodName,\
                                                                     jobjectArray paramKeys,jobjectArray paramValues)
{
    SDK* p_sdk = (SDK*)sdkptr;
    const char * methodNameStr = env->GetStringUTFChars( methodName, );
    //init param map
    jstring jkey,jvalue;
    jsize keysLen=env->GetArrayLength(paramKeys);
    map<string,string> params;
    for(jsize i=;i<keysLen;++i)
    {
        jkey = (jstring)(env->GetObjectArrayElement(paramKeys,i));
        jvalue = (jstring)(env->GetObjectArrayElement(paramValues,i));
        const char *key = env->GetStringUTFChars(jkey, );
        const char *value = env->GetStringUTFChars(jvalue,);
        params[string(key)] = string(value);
        env->ReleaseStringUTFChars(jkey,key);
        env->ReleaseStringUTFChars(jvalue,value);
    }
 
    string result = p_sdk->request(methodNameStr,params);
    env->ReleaseStringUTFChars(methodName,methodNameStr);
    return env->NewStringUTF(result.c_str());
}
 
JNIEXPORT void JNICALL Java_com_pptv_sdk_CommonSDK_requestAsyncNative( JNIEnv* env,jobject thiz,jlong sdkptr,jstring methodName,\
                                            jobjectArray paramKeys,jobjectArray paramValues,jobject callBackObj,jstring callBackMethod)
{
    SDK* p_sdk = (SDK*)sdkptr;
    const char * methodNameStr = env->GetStringUTFChars(methodName, );
    //init param map
    jstring jkey,jvalue;
    jsize keysLen=env->GetArrayLength(paramKeys);
    map<string,string> params;
    for(jsize i=;i<keysLen;++i)
    {
        jkey = (jstring)(env->GetObjectArrayElement(paramKeys,i));
        jvalue = (jstring)(env->GetObjectArrayElement(paramValues,i));
        const char *key = env->GetStringUTFChars(jkey, );
        const char *value = env->GetStringUTFChars(jvalue,);
        params[string(key)] = string(value);
        env->ReleaseStringUTFChars(jkey,key);
        env->ReleaseStringUTFChars(jvalue,value);
    }
    //init callback fun
    JavaCallBackFun* p_callBack = NULL;
    if(callBackObj != NULL && callBackMethod != NULL)
    {
        p_callBack = new JavaCallBackFun(env,callBackObj,callBackMethod,true);
    }
    //async call
    p_sdk->requestAsync(methodNameStr,params,p_callBack);
    env->ReleaseStringUTFChars(methodName,methodNameStr);
}

CommonSDK.java

 package com.pptv.sdk;
 import java.util.Map;
 
 /**
  * CommonSDK is a common interface to interact with sdk.so
  * <p>
  * CommonSDK use jni to call native method written by C++,and it
  * provide a common interface for Java developer.You can directly
  * call the common interface,but it is suggested to use the special
  * interface based on CommonSDK,which is more understandable.
  * @author      guoxiaoqian
  */
 public class CommonSDK implements SDKCallBack
 {
     static
     {
         System.loadLibrary("sdk");
     }
 
     //Exception Call Back
     @Override
     public void callBack(String result)
     {
         // TODO Auto-generated method stub
         System.out.println("Exception occured: "+result);
     }
 
     private long m_sdkHandle;
     private static final CommonSDK m_sdk = new CommonSDK();
 
     private CommonSDK()
     {
         m_sdkHandle = initSDKNative(this,SDKCallBack.callBackName);
     }
 
     /**
      * getInstance()     get a singleton CommonSDK object
      * @return          CommonSDK object
      */
     public static CommonSDK getInstance()
     {
         return m_sdk;
     }
 
     protected void finalize()
     {
         cleanSDKNative(m_sdkHandle);
     }
 
     /**
      * request()             sync request
      * @param methodName    specify the method to call
      * @param params        multi params in key-value map
      * @return              json string containing complex result
      */
     public String request(String methodName,Map<String,String> params)
     {
         String[] keyArr = new String[params.size()];
         String[] valueArr = new String[params.size()];
         int i=;
         for(Map.Entry<String, String> entry:params.entrySet())
         {
             keyArr[i] = entry.getKey();
             valueArr[i] = entry.getValue();
             ++i;
         }
         return requestNative(m_sdkHandle,methodName,keyArr,valueArr);
     }
 
     /**
      * requestAsync()         async request
      * @param methodName    specify the method to call
      * @param params        multi params in key-value map
      * @param callBackObj    specify the obj to handle callback from sdk
      */
     public void requestAsync(String methodName,Map<String,String> params,SDKCallBack callBackObj)
     {
         String[] keyArr = new String[params.size()];
         String[] valueArr = new String[params.size()];
         int i=;
         for(Map.Entry<String, String> entry:params.entrySet())
         {
             keyArr[i] = entry.getKey();
             valueArr[i] = entry.getValue();
             ++i;
         }
         requestAsyncNative(m_sdkHandle,methodName,keyArr,valueArr,callBackObj,callBackObj==null?null:SDKCallBack.callBackName);
     }
 
     private native long initSDKNative(Object callBackObject,String exceptionFun);
     private native void cleanSDKNative(long sdkHandle);
     private native String requestNative(long sdkHandle,String methodName,String keys[],String values[]);
     private native void requestAsyncNative(long sdkHandle,String methodName,String keys[],String values[],Object callBackObject,String callBackFunName);
 
 }

SDKCallBack.java

 package com.pptv.sdk;
 
 /**
  * SDKCallBack is an interface that you must implements when
  * you want to have an object to handle the callback form sdk.
  * @author      guoxiaoqian
  */
 public interface SDKCallBack {
     public final String callBackName = "callBack";
     public abstract void callBack(String result);
 }