Android
Android जावा मूल इंटरफ़ेस (JNI)

परिचय

जेएनआई इंटरफ़ेस के माध्यम से एक मूल पुस्तकालय में फ़ंक्शन कैसे कॉल करें

जावा नेटिव इंटरफ़ेस (JNI) आपको जावा कोड से मूल कार्यों को कॉल करने की अनुमति देता है, और इसके विपरीत। यह उदाहरण दिखाता है कि जेएनआई के माध्यम से एक मूल फ़ंक्शन को कैसे लोड और कॉल किया जा सकता है, यह जेएनआई फ़ंक्शन का उपयोग करके मूल कोड से जावा विधियों और क्षेत्रों तक पहुंचने में नहीं जाता है।

मान लीजिए कि आपके पास project/libs/<architecture> फ़ोल्डर में libjniexample.so नाम की एक मूल लाइब्रेरी है, और आप com.example.jniexample पैकेज के अंदर JNITest जावा वर्ग से एक फ़ंक्शन कॉल करना चाहते हैं।

JNITest वर्ग में, इस तरह से समारोह घोषित करें:

public native int testJNIfunction(int a, int b);

अपने मूल कोड में, फ़ंक्शन को इस तरह परिभाषित करें:

#include <jni.h>

JNIEXPORT jint JNICALL Java_com_example_jniexample_JNITest_testJNIfunction(JNIEnv *pEnv, jobject thiz, jint a, jint b)
{
    return a + b;
}

pEnv तर्क pEnv वातावरण का एक संकेतक है जिसे आप जावा ऑब्जेक्ट और कक्षाओं के तरीकों और क्षेत्रों तक पहुंचने के लिए जेएनआई फ़ंक्शन को पास कर सकते हैं। thiz सूचक एक है jobject जावा उद्देश्य यह है कि देशी पद्धति पर बुलाया गया था के संदर्भ में (या वर्ग करता है, तो वह एक स्थिर तरीका है)।

अपने Java कोड में, JNITest , लाइब्रेरी को इस तरह से लोड करें:

static{
    System.loadLibrary("jniexample");
}

नोट lib शुरू में, और .so फ़ाइल नाम के अंत में छोड़ दिया गया।

जावा से मूल फ़ंक्शन को इस तरह से कॉल करें:

JNITest test = new JNITest();
int c = test.testJNIfunction(3, 4);

देशी कोड से जावा विधि कैसे कॉल करें

जावा नेटिव इंटरफ़ेस (JNI) आपको मूल कोड से जावा फ़ंक्शन को कॉल करने की अनुमति देता है। यह कैसे करना है इसका एक सरल उदाहरण है:

जावा कोड:

package com.example.jniexample;
public class JNITest {
    public static int getAnswer(bool) {
        return 42;
    }
}

देसी कोड:

int getTheAnswer()
{
    // Get JNI environment
    JNIEnv *env = JniGetEnv();

    // Find the Java class - provide package ('.' replaced to '/') and class name
    jclass jniTestClass = env->FindClass("com/example/jniexample/JNITest");

    // Find the Java method - provide parameters inside () and return value (see table below for an explanation of how to encode them) 
    jmethodID getAnswerMethod = env->GetStaticMethodID(jniTestClass, "getAnswer", "(Z)I;");

    // Calling the method
    return (int)env->CallStaticObjectMethod(jniTestClass, getAnswerMethod, (jboolean)true);
}

जावा प्रकार के लिए जेएनआई विधि हस्ताक्षर:

इसलिए हमारे उदाहरण के लिए हमने (Z) I का उपयोग किया - जिसका अर्थ है कि फ़ंक्शन एक बूलियन प्राप्त करता है और एक int देता है।

जेएनआई परत में उपयोगिता विधि

यह विधि C ++ स्ट्रिंग से जावा स्ट्रिंग प्राप्त करने में मदद करेगी।

jstring getJavaStringFromCPPString(JNIEnv *global_env, const char* cstring) {

        jstring nullString = global_env->NewStringUTF(NULL);

        if (!cstring) {
            return nullString;
        }

        jclass strClass = global_env->FindClass("java/lang/String");
        jmethodID ctorID = global_env->GetMethodID(strClass, "<init>",
                "([BLjava/lang/String;)V");
        jstring encoding = global_env->NewStringUTF("UTF-8");

        jbyteArray bytes = global_env->NewByteArray(strlen(cstring));
        global_env->SetByteArrayRegion(bytes, 0, strlen(cstring), (jbyte*) cstring);
        jstring str = (jstring) global_env->NewObject(strClass, ctorID, bytes,
                encoding);

        global_env->DeleteLocalRef(strClass);
        global_env->DeleteLocalRef(encoding);
        global_env->DeleteLocalRef(bytes);

        return str;
    }

यह विधि आपको jbyteArray को char में बदलने में मदद करेगी

char* as_unsigned_char_array(JNIEnv *env, jbyteArray array) {
    jsize length = env->GetArrayLength(array);
    jbyte* buffer = new jbyte[length + 1];

    env->GetByteArrayRegion(array, 0, length, buffer);
    buffer[length] = '\0';

    return (char*) buffer;
}