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.

Some JNI String Functions

1. The GetStringUTFChars function is available through the JNIEnv interface pointer. It converts the jstring reference, typically represented by the Java virtual machine implementation as a Unicode sequence, into a C string represented in the UTF-8 format.
2. The ReleaseStringUTFChars frees the memory used for native string resources. Therefore, calling this function will free the memory taken by the UTF-8 string. Failure to call ReleaseStringUTFChars would result in a memory leak.
3. The NewStringUTF function constructs a new java.lang.String instance in the native method. The NewStringUTF function takes a C string with the UTF-8 format and constructs a java.lang.String instance. The newly constructed java.lang.String instance represents the same sequence of Unicode characters as the given UTF-8 C string.

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 a 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, “My String”);
}

JNI String functions:

JNI String Example:

Let’s write a JNI application that passes a prompt message to a native method, which method prints the prompt message, reads the user input and sends it back to the application.

The Java code will be(NativePrompt.java):

class NativePrompt {
	private native String getInput(String prompt);  //native method
	static   //static initializer code
	{
		System.loadLibrary("NativePrompt");
	} 

	public static void main(String[] args)
	{
		NativePrompt NP = new NativePrompt();
		String sName = NP.getInput("Enter your name: ");
        System.out.println("Hello " + sName);
	}
}

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

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

/* DO NOT EDIT THIS FILE - it is machine generated */
#include "jni.h"
/* Header for class NativePrompt */

#ifndef _Included_NativePrompt
#define _Included_NativePrompt
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     NativePrompt
 * Method:    getInput
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_NativePrompt_getInput
  (JNIEnv *, jobject, jstring);

#ifdef __cplusplus
}
#endif
#endif

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

#include "NativePrompt.h" 
#include "jni.h"
#include "string"
#include "iostream"
#include "vector"

using namespace std;
/*
 * Class:     NativePrompt
 * Method:    getInput
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_NativePrompt_getInput
	(JNIEnv *env, jobject obj, jstring prompt){
	
	string sEntry;
	const char *str;
	str = env->GetStringUTFChars(prompt, NULL);
	if (str == NULL) {
		return env->NewStringUTF("");
	}
	else{
	cout << str; //Frees native string resources env->ReleaseStringUTFChars(prompt, str);
		
		//reads n-consecutive words from the 
		//keyboard and store them in string
		getline(cin, sEntry);
		
        return env->NewStringUTF(sEntry.c_str());
	}
}

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

The post JNI Part 4: JNI Strings 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.

1. Open Visual Studio
2. Click File->New Project, and select Empty project
3. Write Name and select location
4. Click ok

1. Go to Project->Properties
2. On the left side, select general in configuration properties
3. Select Dynamic Library(.dll) as configuration Type

1. Next click C/C++
2. Add jdk include and win32 path in Additional Include Directories
3. If you have installed jdk in c program files then the path is
4. C:\Program Files\Java\jdk1.6.0_18\include; C:\Program Files\Java\jdk1.6.0_18\include\win32
5. Click OK button.

1. Now the configuration of the project is done. Next step is to add files to the project.
2. As shown in below image, right click on the “Header Files” folder and select Add, Existing Item
3. Select Header files and add to the project.

Finally solution explorer will look like:

1. Build Solution: Go to Build->Build Solution
2. Solve the errors if any found in output window.
3. Once the build is successful then the generated dll will be in the output directory.

The post JNI Part 2: Visual Studio setup for DLL Project first appeared on Student Projects.

1. JNI stands for Java Native Interface
2. JNI specifies a communication protocol between Java code and external, native code.
3. It enables your Java code to interface with native code written in other languages (such as C, C++)
4. Native code typically accesses the CPU and registers directly and is thus faster than interpreted code (like Java)
5. Java native methods are methods declared in your Java code (much like you declare an abstract method), but which are actually implemented in another programming language.

JNI allows Java programmers to

1. Leverage platform specific features outside a JVM. For example, you typically can’t write a device driver in Java because you can’t directly access the hardware
2. Leverage the improved speed possible with natively compiled code (such as C or assembler). For example, you might need an extremely fast math routine for a scientific application or game program.
3. Utilize existing code libraries in your Java programs. For example, there might be a really good file compression library written in C. Why try to rewrite it in Java when you can access it using JNI?

JNI Drawbacks

1. Your program is no longer platform independent
2. Your program is not as robust. If there is a null pointer exception in your native code, the JVM can’t display a helpful message. It might even lock up.

JNI supports

1. Native methods can create and manipulate Java objects such as strings and arrays.
2. Native methods can manipulate and update Java objects passed into them (as parameters)
3. You can catch and throw exceptions from native methods and handle these exceptions in either the native method or your Java application
4. This almost seamless sharing of objects makes it very easy to incorporate native methods in your Java code

The Role of JNI

1. As a part of the Java virtual machine implementation, the JNI is a two-way interface that allows Java applications to invoke native code and vice versa.
2. The JNI is designed to handle situations where you need to combine Java applications with native code.
3. As a two-way interface, the JNI can support two types of native code: native libraries and native applications.

JNI “Hello World!” Application

Let’s create the JNI “Hello World” application – a Java application that calls a C function via JNI to print “Hello World!”.

The process consists of the following steps:

1. Create a class (HelloWorld.java) that declares the native method.
2. Use javac to compile the HelloWorld source file, resulting in the class file HelloWorld.class.
3. Use javah -jni to generate a C header file (HelloWorld.h) containing the function prototype for the native method implementation. The javah tool is provided with JDK or Java 2 SDK releases.
4. Write the C implementation (CLibHelloWorld.c) of the native method.
5. Compile the C implementation into a native library, creating HelloWorld.dll.
6. Run the HelloWorld program using the java runtime interpreter. Both the class file (HelloWorld.class) and the native library (HelloWorld.dll) are loaded at runtime.

The program defines a class named HelloWorld that contains a native method print().
1. Create a class (HelloWorld.java)

class HelloWorld {
	public native void print();  //native method
	static   //static initializer code
	{
		System.loadLibrary("CLibHelloWorld");
	} 

	public static void main(String[] args)
	{
		HelloWorld hw = new HelloWorld();
        hw.print();
	}
}

There are two remarkable things here.

1. First one is the declaration of a native method using the keyword native.

public native void print();

This tells the compiler that print() will be accessed from an external library, and that it should not look for it in the Java source code. Accordingly, notice that there is no implementation of this method present in the Java code.

2. The second remarkable section of code is the following:

static {
        System.loadLibrary(“CLibHelloWorld"); //**** Loads CLibHelloWorld.dll
}

•    Before the native method print() can be called, the native library that implements print must be loaded. The code above loads the native library in the static  initializer of the HelloWorld class.
•    The Java VM automatically runs the static initializer before invoking any methods in the CLibHelloWorld class.

Next we compile the JNI HelloWorld java application as follows:

Having the application compiled we can use the javah tool to generate the header (h) file that declares the native method print().

javah –jni HelloWorld

• – The name of the header file is the class name with a “.h” appended to the end of it.
• – The command shown above generates a file named HelloWorld.h.

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

#ifndef _Included_HelloWorld
#define _Included_HelloWorld
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     HelloWorld
 * Method:    print
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_HelloWorld_print
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

In the below line

JNIEXPORT void JNICALL Java_HelloWorld_print  (JNIEnv *, jobject);

•    The method name is prefixed with Java_ and then the full name of the class to which it belongs, then the function name.
•    This is to distinguish it from methods that belong to other classes and might have the same name.
•    The first argument for every native method implementation is a JNIEnv interface pointer.
•    The second argument is a reference to the HelloWorld object itself.

Writing the implementation:

Write the native C/C++ code which implements the method. Use the same signature that your header file uses. You might name your file something like “CLibHelloWorld.c”.

#include "HelloWorld.h"
#include "jni.h"
#include  "stdio.h"

JNIEXPORT void JNICALL Java_HelloWorld_print(JNIEnv *env, jobject obj)
{
  printf("Hello world\n");
  return;
}

Here

• We use the printf function to display the string “Hello World!”.
• Both arguments, the JNIEnv pointer and the reference to the object, are ignored.
• The C program includes three header files:
  • jni.h – provides information the native code needs to call JNI functions.
  • stdio.h – implements the printf() function.
  • HelloWorld.h – generated by using javah, it includes the C/C++ prototype for the Java_HelloWorld_print function.

Compile the C/C++ code into a library (a DLL if your code will run under Windows). – Click here to read step by step procedure to create DLL project using Visula Studio.

If you use C++ Builder to compile your library under Windows, make sure you create a DLL project and then add the C/C++ file to it (e.g. CLibHelloWorld.c). You’ll need to add the following to your compiler’s include path:

• \\javadir\\include
• \\javadir\\include\\win32

Be sure to name your project CLibHelloWorld so the DLL it creates will be named c_library.dll.

Run the Java class (main method). Be sure all the files and dll are in one folder.

java HelloWorld

You should see “Hello world” appear on the screen!

If you see a “java.lang.UnsatisfiedLinkError” error message, then Java couldn’t find your shared library OR mismatch in native functions.

The post JNI Part1: Java Native Interface Introduction and “Hello World” application first appeared on Student Projects.