I am trying to implement some C code in Java by using SWIG 1.3. Now I have to rebuild some existing C into Java code and to provide a function pointer to a Java function to the C method.
The C code: net.c:
void register_message_handler( context_t *ctx, message_handler_t handler) {
context->msg_handler = (void (*)( void *, coap_queue_t *, void *)) handler;
}
client.c:
void message_handler(context_t *ctx, queue_t *node, void *data) {
...
}
int main(int argc, char **argv) {
// setup ctx
register_message_handler( ctx, message_handler );
}
All I already have in Java is:
public static void message_handler(def.SWIGTYPE_p_context_t ctx, def.SWIGTYPE_p_queue_t node, String data ) {}
and this should be registered as callback in the same way as it is done in the above C code, now in Java:
net.register_message_handler(ctx, message_handler);
What I found was http://www.swig.org/Doc1.3/SWIGDocumentation.html#SWIG_nn30 including an undefined reference at the end of this chapter: "And now, a final note about function pointer support. Although SWIG does not normally allow callback functions to be written in the target language, this can be accomplished with the use of typemaps and other advanced SWIG features. This is described in a later chapter." Where does this refer to?
I also found a solution for C++, but is there a way to adapt this to C? Swig c++ w/ Java loses type on polymorphic callback functions morphic-callback-functions
Thanks for your help.
A callback is any executable code that is passed as an argument to other code, which is expected to call back (execute) the argument at a given time [Source : Wiki]. In simple language, If a reference of a function is passed to another function as an argument to call it, then it will be called as a Callback function.
Registering a callback function simply means that you are arranging for an external entity to call your function. It might happen at a later time, or it might happen straight away. A straightforward example is qsort .
The main advantage of using callbacks is that you can call a function that is defined in a higher software level from a lower software level subroutine. A callback can be used for notifications or signals.
I remember scratching my head over this reference in the SWIG manual too.
You can do this as follows without the esoteric features:
You need a mechanism to dispatch the incoming C callback into Java. For that you need the object ID of the object that you are calling into, and the method ID of your handler. In your C registration helper, create Global References for those and cache them for use by the callback.
You also need a class ID and constructor method ID for anything that you want to pass to the java callback as a parameter. You also want to cache Global References to those.
In the C part of the callback, look up your method IDs, construct arguments and call into Java.
The thread that the callback comes in on, needs to be attached to the Java VM (with the JNI function AttachCurrentThread()). This is where you get your JNIEnv pointer from. This pointer is only valid in the context of the thread that you invoked AttachCurrentThread() from! What this means is that if you have callbacks coming in on multiple threads, you need to cache the JNIEnv * in thread local storage.
Make sure you check return values after returning from JNI functions
Make sure to check ExceptionOccurred() after any and all calls back into Java. Not doing this really gets you in trouble in hard to debug ways.
I found this relatively easy to debug with Eclipse and Visual Studio as follows: Start main Java program from Eclipse, attach Visual Studio Debugger to that process. You can set breakpoints on either side.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With