Java Tech - Chapter 22 : JNI

NativeJNIDemo.cpp

#include "javatech_jni22_JNIDemo.h"

JNIEXPORT void JNICALL
  Java_javatech_jni22_JNIDemo_doStatic (JNIEnv *jenv, jclass cls)
{} // doStatic

JNIEXPORT void JNICALL
  Java_javatech_jni22_JNIDemo_doSomething (JNIEnv *jenv, jobject jo)
{
  // Find the jclass corresponding to the jobject
  jclass cls = jenv->GetObjectClass (jo);

  // Get the static a_static_float field.
  jfieldID fid = jenv->GetStaticFieldID (cls, "a_static_float", "F");
  jfloat a_static_float = jenv->GetStaticFloatField (cls, fid);
  printf ("got a_static_float = %f\n", a_static_float);

  // Find the field ID of the 'my_custom' field
  jfieldID my_custom_fid = jenv->GetFieldID (
    cls, "my_custom", "Ljavatech/jni22/MyCustomObject;"
  );
  if (my_custom_fid == NULL)
    return;
  printf ("got my_custom_fid\n");

  // Get the jobject reference to 'my_custom'
  jobject my_custom_jo = jenv->GetObjectField (jo, my_custom_fid);
  printf ("got my_custom_jo\n");

  // Find the jclass of the my_custom_jo jobject.
  jclass my_custom_cls = jenv->GetObjectClass (my_custom_jo);
  printf ("got my_custom_cls\n");

  // Find the field ID of the 'val' field of MyCustomObject.
  jfieldID val_fid = jenv->GetFieldID (my_custom_cls, "val", "I");
  if (val_fid == NULL) {
    jthrowable jth = jenv->ExceptionOccurred ();
    if (jth) {
      printf ("  there was an exception\n");
      jenv->ExceptionDescribe ();
      jenv->ExceptionClear ();
      printf ("  described and cleared it\n");
    }
    return;
  }
  printf ("got val_fid\n");

  // Get the 'val' field
  jint val = jenv->GetIntField (my_custom_jo, val_fid);
  printf ("got val = %d\n", val);

  // Manipulate it somehow
  jint multiplier = (jint) a_static_float;
  val *= multiplier;
  printf ("multiplied it by %f\n", a_static_float);

  // Set it back into my_custom_jo
  jenv->SetIntField (my_custom_jo, val_fid, val);
  printf ("put it back into my_custom_jo\n");

  // Get the method ID to call a Java method
  jmethodID mid = jenv->GetMethodID (cls, "callback", "(I)I");
  if (mid == NULL)
    return;
  printf ("got mid\n");

  jint param = 8;
  // Call the Java method
  printf ("calling Java 'callback' method\n");
  jint ret = jenv->CallIntMethod (jo, mid, param);
  // Check for any exception that may have occurred during the Java method
  jthrowable jth = jenv->ExceptionOccurred ();
  if (jth) {
    printf ("  there was an exception\n");
    jenv->ExceptionDescribe ();
    jenv->ExceptionClear ();
    printf ("  did not return from Java 'callback'\n");
  }
  else
    printf ("  return from 'callback' = %d\n", ret);
} // doSomething

NativeHelloWorld.cpp

#include "javatech_jni22_JNIHelloWorld.h"
#include <stdio.h>

// This is the non-static native method. Note that it receives a jobject
// argument inthe second position.
JNIEXPORT void JNICALL
  Java_javatech_jni22_JNIHelloWorld_nativeHelloWorld
  (JNIEnv *, jobject)
{
  printf ("   Hello World (non-static)\n");
  return;
}

// The static native method receives a jclass variable in the second position.
JNIEXPORT void JNICALL
  Java_javatech_jni22_JNIHelloWorld_nativeHelloWorldStatic
  (JNIEnv *, jclass)
{
  printf ("   Hello World (static)\n");
  return;
}

NativeString.cpp

#include "javatech_jni22_StringExample.h"
#include <stdio.h>
#include <string.h>

JNIEXPORT jstring JNICALL
  Java_javatech_jni22_StringExample_nativeProcessString
  (JNIEnv *jenv, jobject jo, jstring js)
{
  // Get jstring into C string format.
  const char* cs = jenv->GetStringUTFChars (js, NULL);
  char *cstring = new char [strlen (cs) + 1]; // +1 for null terminator
  sprintf (cstring, "%s", cs);
  jenv->ReleaseStringUTFChars (js, cs);

  // Reverse the order of characters.
  int len = strlen (cstring);
  char *reverse = new char [len+1]; // + 1 for null terminator
  for (int i=0; i < len; i++)
    reverse[i] = cstring[len-i-1];
  reverse[len] = 0; // null terminate

  // Create a new jstring for return.
  jstring jreverse = jenv->NewStringUTF (reverse);
  return jreverse;
} // nativeProcessString

NativeArray.cpp

#include "javatech_jni22_ArrayExample.h"

JNIEXPORT jfloat JNICALL
  Java_javatech_jni22_ArrayExample_nativeProcessArray
  (JNIEnv *jenv, jobject, jfloatArray the_jarray, jint j_index)
{
  float* c_array = jenv->GetFloatArrayElements (the_jarray, NULL);
  c_array[3] = -999.f;
  int c_index = j_index;
  float element = c_array[c_index];
  jenv->ReleaseFloatArrayElements (the_jarray, c_array, 0);
  jfloat jelement = element;
  return jelement;
} // nativeProcessArray

JNIEXPORT jint JNICALL
  Java_javatech_jni22_ArrayExample_nativeProcessArrayRegion
  (JNIEnv *jenv, jobject, jintArray the_jarray)
{
  jint region[10];
  jint sum = 0;
  jenv->GetIntArrayRegion (the_jarray, 5, 10, region);
  for (int i=0; i < 10; i++)
    sum += region[i];
  return sum;
} // nativeProcessArrayRegion

JNIEXPORT void JNICALL
  Java_javatech_jni22_ArrayExample_nativeModifyArrayRegion
  (JNIEnv *jenv, jobject, jintArray the_jarray)
{
  jint region[10];
  for (int i=0; i < 10; i++)
    region[i] = -5 - i;
  jenv->SetIntArrayRegion (the_jarray, 5, 10, region);
} // nativeProcessArrayRegion

JNIEXPORT void JNICALL
  Java_javatech_jni22_ArrayExample_nativeProcess2DArray
  (JNIEnv *jenv, jobject, jobjectArray joa2d)
{
  // Get the length of the 2D array
  jint len1 = jenv->GetArrayLength (joa2d);
  // Extract the 0-th element from the 2D array and cast into a jintArray
  jintArray i2d_0 = (jintArray) jenv->GetObjectArrayElement (joa2d, 0);
  // Get the length of the extracted 1D array
  jint len2 = jenv->GetArrayLength (i2d_0);

  // Allocate a buffer to receive a copy of the elements from the 1D array
  jint buffer[4];
  // Copy the all of the elements of the entire 1D array into the buffer
  jenv->GetIntArrayRegion (i2d_0, 0, 4, buffer);
  // Modify them in some way.
  for (int i=0; i < 4; i++)
    buffer[i]*=2;
  // Insert the modified buffer back into the 1D array.
  jenv->SetIntArrayRegion (i2d_0, 0, 4, buffer);
} // nativeProcessArrayRegion