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, 0);
        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, 0);
    //init param map
    jstring jkey,jvalue;
    jsize keysLen=env->GetArrayLength(paramKeys);
    map<string,string> params;
    for(jsize i=0;i<keysLen;++i)
    {
        jkey = (jstring)(env->GetObjectArrayElement(paramKeys,i));
        jvalue = (jstring)(env->GetObjectArrayElement(paramValues,i));
        const char *key = env->GetStringUTFChars(jkey, 0);
        const char *value = env->GetStringUTFChars(jvalue,0);
        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, 0);
    //init param map
    jstring jkey,jvalue;
    jsize keysLen=env->GetArrayLength(paramKeys);
    map<string,string> params;
    for(jsize i=0;i<keysLen;++i)
    {
        jkey = (jstring)(env->GetObjectArrayElement(paramKeys,i));
        jvalue = (jstring)(env->GetObjectArrayElement(paramValues,i));
        const char *key = env->GetStringUTFChars(jkey, 0);
        const char *value = env->GetStringUTFChars(jvalue,0);
        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=0;
        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=0;
        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);
}