Example: Accessing intarray

JNIExport jint JNICALL Java_IntArray_sumArray(JNIEnv *env, jobject obj,
	jintArray arr){
		jsize len = *env->GetArrayLength(env,arr);
		jint *body = *env->GetIntArrayElements(env,arr,0);
		for (jint i = 0; i < len; ++i){
			sum += body[i];
		}
	*env->ReleastIntArrayElements(env, arr, body, 0);
}

JNI Array Example program

Let’s write a JNI application that passes an unsorted integer array to a native method, which method sorts and sends it back to the application.

The Java code will be(SortArray.java):

class SortArray {
	private native int[] sort(int[] arr);  //native method 

	static   //static initializer code
	{
		System.loadLibrary("SortArray");
	} 

	public static void main(String[] args)
	{
		int iArr[] = {4,5,2,7,1,9}; // Input array
		int oArr[]; //Output array

		SortArray arr = new SortArray();

		System.out.println("Unsorted array: ");
		for(int i = 0; i < iArr.length; i++){
			System.out.println(iArr[i] + " ");
		}

		oArr = arr.sort(iArr);

		System.out.println("Sorted array: ");
		for(int i = 0; i < oArr.length; i++){
			System.out.println(oArr[i] + " ");
		}
	}
}

Compile SortArray.java (javac SortArray.java) and generate hedder file(javah -jni SortArray).

The generated with javah header file SortArray.h will be:

/* DO NOT EDIT THIS FILE - it is machine generated */
#include
/* Header for class SortArray */

#ifndef _Included_SortArray
#define _Included_SortArray
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     SortArray
 * Method:    sort
 * Signature: ([I)[I
 */
JNIEXPORT jintArray JNICALL Java_SortArray_sort
  (JNIEnv *, jobject, jintArray);

#ifdef __cplusplus
}
#endif
#endif

The C++ implementation file SortArray.cpp will be:

#include "SortArray.h"
#include "jni.h"

/*
 * Class:     SortArray
 * Method:    sort
 * Signature: ([I)[I
 */
JNIEXPORT jintArray JNICALL Java_SortArray_sort
    (JNIEnv *env, jobject obj, jintArray arr){

    jsize arrLength = env->GetArrayLength(arr);
    jintArray arrSorted = env->NewIntArray(arrLength); 

    jint *arrOut = NULL;
    arrOut = env->GetIntArrayElements(arr, 0);

    for(jsize x = 0; x < arrLength; x++){
        for(jsize y = 0; y < arrLength - 1; y++){
                        if(arrOut[y] > arrOut[y+1]){
				jsize temp = arrOut[y+1];
				arrOut[y+1] = arrOut[y];
				arrOut[y] = temp;
			}
		}
	}

    env->SetIntArrayRegion(arrSorted, 0, arrLength, arrOut);
    env->ReleaseIntArrayElements(arr, arrOut, 0);

    return arrSorted;
}

Run the program (java SortArray) and verify the output.

The post JNI Part 5: JNI Arrays first appeared on Student Projects.

Mapping Types

1. Argument types in the native method declaration have corresponding types in native programming languages.
2. The JNI defines a set of C and C++ types that correspond to types in the Java programming language.
3. There are two kinds of types in the Java programming language:
   1. Primitive types such as int, float, double and char;
   2. Reference types such as classes and arrays.
4. The variables of primitive types contain a single value – a number, character or boolean value. A variable of primitive type has a specified size and format.
5. The variables of reference type contain a reference to (an address of) the value or set of values represented by the variable. Arrays, classes and interfaces are reference types.
6. The JNI treats primitive types and reference types differently.
7. The JNI passes objects to native methods as opaque references.
8. Opaque references are C pointer types that refer to internal data structures in the Java virtual machine.
9. The exact layout of the internal data structures, however, is hidden from the programmer.
10. All JNI references are of or inherit the type jobject.

Primitive types: There are eight primitive types in Java

The mapping of primitive types is straightforward.

Example:

1. The type int in the Java programming language maps to the C/C++ type jint (defined in jni.h as a signed 32-bit integer),
2. The type float in the Java programming language maps to the C and C++ type jfloat (defined in jni.h as a 32-bit floating point number).

Reference types:

1. Here Objects are passed by reference
2. All objects have type jobject as shown in below image

The native code must manipulate the underlying objects via the appropriate JNI functions, which are available through the JNIEnv interface pointer.

Example:
The corresponding JNI type for java.lang.String is jstring. The exact value of a jstring reference is irrelevant to the native code. The native code calls JNI functions such as GetStringUTFChars() to access the contents of a string.

The post JNI Part 3: Passing Arguments and Mapping Types first appeared on Student Projects.

jstring, which requires a subroutine call to in order to convert a Java Unicode string (2 bytes) to a C-style char* string (1 byte UTF-8 format).

To convert a jstring to a C-style string, you might write code like the following:

JNIEXPORT void JNICALLJava_MyJavaClass_printName(JNIEnv *env, jobject obj,
	jstring name)
{
	const char *str= (*env)->GetStringUTFChars(env,name,0);
	printf(“%s”, str);
	//need to release this string when done with it in order to
	//avoid memory leak
	(*env)->ReleaseStringUTFChars(env, name, str);
}

To convert a C-style string to jstring , you can use the (*env)->NewStringUTF() function to create a new jstring from a C-style string. For example, a C function that needs to return a Java string could contain the following code:

JNIEXPORT jstring JNICALLJava_MyJavaClass_getName(JNIEnv *env, jobject obj)
{
	return (*env)->NewStringUTF(env, “Electrofriends.com”);
}

The post How to convert a jstring to a C-style string or vice versa? first appeared on Student Projects.