{"id":141,"date":"2007-03-27T22:37:00","date_gmt":"2007-03-27T22:37:00","guid":{"rendered":"https:\/\/zofxare.com\/zofxare\/blog\/2007\/03\/27\/jni-c-object-instantiation\/"},"modified":"2007-03-27T22:37:00","modified_gmt":"2007-03-27T22:37:00","slug":"jni-c-object-instantiation","status":"publish","type":"post","link":"https:\/\/zofxare.com\/zofxare\/blog\/2007\/03\/27\/jni-c-object-instantiation\/","title":{"rendered":"JNI, C++ object instantiation"},"content":{"rendered":"

So my next task is to create a java gui using a C++ library.
The library is pretty simple. There is one main class with a few supporting classes. The supporting classes are basically just structs which hold variables.
The first thing to be done is create a Java class similar to the main C++ class. This is called a peer class<\/a>. The methods in the java class are native functions whose implementations will be done using the Java Native Interface (JNI).<\/a>
In the java class constructor, a jni call to create the C++ class will need to be made. The java class will also need to override the finalize function in which it will have a jni call to delete the C++ class.
The java class also needs to contain a variable which will be used to contain the pointer to the C++ class.
Now my first problem: How do I implement the JNI function which creates the C++ class? If anyone knows the answer, feel free to leave me a comment.
According to this link<\/a>, a reinterpret cast is involved. <\/p>\n

C++ class:<\/p>\n

#include “CPPObject.h”
#include <\/p>\n

CppObject::CppObject(int aFoo) {
foo = aFoo;
} <\/p>\n

void CppObject::printFoo() {
printf (“Value of foo is: %in”, foo);
} <\/p>\n

Java peer class:<\/p>\n

public class CppObjectPeer {
static {
System.loadLibrary(“cppobjects”);
}
protected long ptr;
public CppObjectPeer(int aFoo) {
this.ptr = createCppObject(aFoo); \/\/create object in native code
}
public void printFoo() {
printFoo(this.ptr); \/\/print from native code
}
\/\/native methods
private final native long createCppObject(int aFoo);
private native void printFoo(long ptr);
} <\/p>\n

Jni implementations:<\/p>\n

JNIEXPORT jlong JNICALL Java_CppObjectPeer_createCppObject
(JNIEnv *env, jobject obj, jint fooValue) {
CppObject *cppObj = new CppObject(fooValue);
return reinterpret_cast(cppObj);
}<\/p>\n

JNIEXPORT void JNICALL Java_CppObjectPeer_printFoo
(JNIEnv *env, jobject obj, jlong ptr) {
CppObject *cppObj = reinterpret_cast(ptr);
cppObj->printFoo();
} <\/p>\n

Well, it looks simple enough. Just not sure why the book: Essential Jni: Java Native Interface (Essential Java)<\/a>\"\", by Rob Gordon doesn’t use this technique. Is this a new technique?<\/p>\n

The book uses a Registry class and a hash code function to store the pointer to the C++ object. This method seems like a lot of work for what I need. As an alternative, he suggests using get\/setCID functions which call get\/setLongField functions. The set functions requires an int val be passed in and I don’t understand where the val comes from. I guess for now I’m going to try the reinterpret_cast method.
Stay tuned for how it works out.<\/p>\n