Implémenter la fonction de rappel dans JNI en utilisant l'interface

J'ai besoin pour mettre en œuvre fonction de rappel en Java à l'aide de “interface”. J'ai écrit l'application de la partie comme MyJavaFunction(int size, m_GetSizeInterface);

m_GetSizeInterface est une Interface qui contient la fonction de rappel GetSize. Cette méthode GetSize est de remplacer dans l'application. Dans JNI j'ai besoin d'appeler une RPC fonction ayant prototype int MyCPPFunction(int size, int (*callback)(int* ID));

Comment puis-je passer ce GetSize comme paramètre à MyCPPFunction dans JNI? S'il vous plaît aider

public int GetSize (m_SizeClass arg0)
{
    g_size = arg0.size;
        return 0;
}

source d'informationauteur indira | 2011-07-19

  1. 15

    La complication ici est que vous voulez l'appeler du code C++ natif qui vous aussi, vous voulez appeler une méthode en java. C'est en fait un peu délicat.

    Vous avez besoin pour créer un JNI fonction C++ java à l'appel, et une fonction C++ correspondant
    le MyCPPFunction signature de rappel. Ce dernier agira comme un wrapper pour appeler la méthode java.

    Parce que le wrapper ont besoin d'informations sur la JNI de l'environnement, qui ne peuvent être fournies par des paramètres (de peur que l'on se ruine la signature) vous pouvez créer un peu de variables globales pour le tenir:

    jobject g_getSizeIface;
jmethodID g_method;
JNIEnv *g_env;

    La fonction C++ java qui fera appel est le suivant: 

    JNIEXPORT void JNICALL Java_ClassName_MyCPPFunction
     (JNIEnv *env, jint size, jobject getSizeInterface)
{
      jclass objclass = env->GetObjectClass(getSizeInterface);
      jmethodID method = env->GetMethodID(objclass, "GetSize", "(m_SizeClass)I");
      if(methodID == 0){
          cout << "could not get method id!\n";
          return;
      }
      g_method = method;
      g_getSizeIface = getSizeInterface;
      g_env = env
      MyCPPFunction(size, WrapperFunc);
}

    Et la fonction wrapper est donc:

    int WrapperFunc(int *id)
{
      jint retval;
      //marshalling an int* to a m_SizeClass boogy-woogy.
      ...
      g_env->ExceptionClear();
      retval = g_env->CallIntMethod(g_getSizeIface, g_method, 
                                    /*marshalled m_SizeClass*/);
      if(g_env->ExceptionOccured()){
          //panic! Light fires! The British are coming!!!
          ...
          g_env->ExceptionClear();
      }     
      return rvalue;
}
  2. 0
    #include <functional>
#include <cstdlib>
#include <map>

class SimpleQueueEvent {

public:

    SimpleQueueEvent(){};
    ~SimpleQueueEvent(){};

    //for C++ code call
    int queueEvent(std::function<void(void)> func){
        int curTime = time(0) + rand() % 10000;
        eventMaps.insert(std::map<int, std::function<void(void)>>::value_type(curTime, func));
        return curTime;

        //Call Java method to invoke method, such as
        //env->FindClass("....");
        //jmethodID method = env->FindMethod("onPostQueueEvent"...);
        //env->InvokeVoidMethod();

        //Java code like this..
        //private void onPostQueueEvent(final int eventId){
        //listener.PostQueueEvent(new Runnable() {
        //   public void run() {
        //       nativeEventFunc(eventId);
        //   }
        //});
        //private static native void nativeEventFunc(int eventId);

    }

    void nativeEventFunc(int eventId){
        if(eventMaps.find(eventId) != eventMaps.end()){
            std::function<void(void)> func = eventMaps.at(eventId);
            func();
        }
    }



private:
    std::map<int, std::function<void(void)>> eventMaps;


};

    //et le code de test est:

     SimpleQueueEvent queueEvent;
    std::function<void(void)> func = [](){
        printf("native runnable..\n");
    };

    int evenId = queueEvent.queueEvent(func);
    queueEvent.nativeEventFunc(evenId);