Eclipse + JNI: Can find library but not method

Question

I am trying to write c++ bindings for a library, so for learning to you, I am using th the following simple java and C++ code. And I am using SWIG.

The java code:

public class App {

    static{
        System.loadLibrary("demo");
    }

    public static void main(String[] args) {

        // TODO Auto-generated method stub
        System.out.println(System.getProperty("java.library.path"));
        printHello("Lars");
    }

    native static void printHello(String name);
}

My C++ code:

#include <iostream>
#include <string>
#include "demo.hpp"

void printHello(std::string name){
    std::cout << "Hello: "<< name << "\n";
}

My header:

void printHello(std::string);

The .i file for SWIG:

%module demo
%include "std_string.i"
%{
  #include <iostream>
  #include <string>
  #include "demo.hpp"
%}
  extern void printHello(std::string);

I ran swig -c++ -java demo.i no problems there. compiled with:

g++ -c -fPIC demo_wrap.cxx -I/usr/lib64/jvm/java-1.7.0-openjdk-1.7.0/include/ -I/usr/lib64/jvm/java-1.7.0-openjdk-1.7.0/include/linux

And made a shared library and moved it to /usr/lib

g++ -shared demo_wrap.o -o libdemo.so

But then I tried to run my java program using, eclipse and I got this error:

Exception in thread "main" java.lang.UnsatisfiedLinkError: App.printHello(Ljava/lang/String;)V
    at App.printHello(Native Method)
    at App.main(App.java:11)

So from what I can tell, eclipse / java knows my library exist, but it can't find my function/method in the library. Is there something I have done wrong? or I am missing something?

Thanks it advance

EDIT: If the content of demoJNI.java might help

public class demoJNI {
  public final static native void printHello(String jarg1);
}

Demo_wrap.cxx

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 2.0.10
 * 
 * This file is not intended to be easily readable and contains a number of 
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG 
 * interface file instead. 
 * ----------------------------------------------------------------------------- */

#define SWIGJAVA


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__)) 
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__)) 
# else
#   define SWIGUNUSED 
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif 
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif 
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif



/* Fix for jlong on some versions of gcc on Windows */
#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
  typedef long long __int64;
#endif

/* Fix for jlong on 64-bit x86 Solaris */
#if defined(__x86_64)
# ifdef _LP64
#   undef _LP64
# endif
#endif

#include <jni.h>
#include <stdlib.h>
#include <string.h>


/* Support for throwing Java exceptions */
typedef enum {
  SWIG_JavaOutOfMemoryError = 1, 
  SWIG_JavaIOException, 
  SWIG_JavaRuntimeException, 
  SWIG_JavaIndexOutOfBoundsException,
  SWIG_JavaArithmeticException,
  SWIG_JavaIllegalArgumentException,
  SWIG_JavaNullPointerException,
  SWIG_JavaDirectorPureVirtual,
  SWIG_JavaUnknownError
} SWIG_JavaExceptionCodes;

typedef struct {
  SWIG_JavaExceptionCodes code;
  const char *java_exception;
} SWIG_JavaExceptions_t;


static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
  jclass excep;
  static const SWIG_JavaExceptions_t java_exceptions[] = {
    { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
    { SWIG_JavaIOException, "java/io/IOException" },
    { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
    { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
    { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
    { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
    { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
    { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
    { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
    { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
  };
  const SWIG_JavaExceptions_t *except_ptr = java_exceptions;

  while (except_ptr->code != code && except_ptr->code)
    except_ptr++;

  jenv->ExceptionClear();
  excep = jenv->FindClass(except_ptr->java_exception);
  if (excep)
    jenv->ThrowNew(excep, msg);
}


/* Contract support */

#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else


#include <string>


  #include <iostream>
  #include <string>
  #include "demo.hpp"


#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT void JNICALL Java_demoJNI_printHello(JNIEnv *jenv, jclass jcls, jstring jarg1) {
  std::string arg1 ;

  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  } 
  const char *arg1_pstr = (const char *)jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return ;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  printHello(arg1);
}


#ifdef __cplusplus
}
#endif

UnsatisfiedLinkError usually means that the architecture of the files used for building are different than running. Is your JDK 64 bit or 32 bit? And the platform where you built your `SO` file is 32 or 64? — Pat, Jul 25 '14 at 12:48
Possible duplicate of _[Using SWIG with methods that take std::string as a parameter](http://stackoverflow.com/questions/9122511/using-swig-with-methods-that-take-stdstring-as-a-parameter)_; TL;NR: your **.i** file needs `%include "std_string.i"` — Alex Cohn, Jul 25 '14 at 21:22
@AlexCohn I have updated my .i file look above, but I still get the same error — Lars Nielsen, Jul 28 '14 at 06:15

score 1 · Accepted Answer · answered Jul 29 '14 at 09:29

It comes out that I had a misconception of what SWIG is doing. Probably, you too.

The purpose of SWIG is to automate building wrappers for C/C++ libraries. It is not a replacement to javah. Working though SWIG, you start with C or C++ code, and receive autogenerated C++ and Java code. With this, you can use these wrapper Java classes (in your case, demoJNI) in your project. You don't declare native methods in your Java code. You communicate to your C++ library through the wrapper Java classes and wrapper C/C++ code (Demo_wrap.cxx and demoJNI.java).

SWIG documentation explicitly says that it is not the right tool to connect Java code to a couple of native functions. It was designed with an ambition to automate wrapping of huge C++ projects with complex APIs, with Java, Python, and many other high-level languages.

score 0 · Answer 2 · edited Jul 25 '14 at 23:23

0

In you C++ code you should do something like:

extern "C" {  
    JNIEXPORT void JNICALL

    Java_App_printHello(JNIEnv* env, jobject obj, jstring name) {
        const char* c_name = env -> GetStringUTFChars(name , NULL);
        std::cout << "Hello: "<< c_str << "\n";
        env->ReleaseStringUTFChars(name, c_name);
    }
}

edited Jul 25 '14 at 23:23

Mikael Engver

4,634
4
46
53

answered Jul 25 '14 at 23:07

beef

11
1

2

That's what SWIG should take care of. – Alex Cohn Jul 25 '14 at 23:10

Eclipse + JNI: Can find library but not method

2 Answers2