MWEJavaInterface

#include <jni.h>

#include <string>
#include <cassert>
#include <iostream>

#include <stdexcept>

class MWEJavaInterface
{
    private:
        std::string MWE_str;

        // Java context
        JNIEnv*     JNIEnvironment;
        JavaVM*     javaVM;

        std::string javaClassPath;
        std::string javaClassName;

        // Java class
        jclass      javaClass;

        // Java object (class instance)
        jobject     javaClassInstance;

        // Java methods
        jmethodID   IDconstructor;      // ()V
        jmethodID   IDsetString;        // (Ljava/lang/String;)V
        jmethodID   IDgetString;        // ()Ljava/lang/String;

    public:
        MWEJavaInterface();

        void init_context( void);               //Init methods
        void init_class( void);
        void init_methods( void);

        void j_constructor( void);
        void j_setString( std::string);
        std::string j_getString( void);

};
MWEJavaInterface::MWEJavaInterface()
{
    this->javaClassPath  = "/home/user/Documents/MWE"; //CHANGE HERE
    this->javaClassName  = "EXICodec";

    this->javaClass      = NULL;
    this->javaClassInstance = NULL;

    this->IDconstructor      = NULL;
    this->IDsetString        = NULL;
    this->IDgetString        = NULL;
}

void MWEJavaInterface::init_context()
{
    const std::string optionString("-Djava.class.path="+this->javaClassPath);

    JavaVMOption options[3] = {
        { const_cast<char*>("-Xmx128m"), NULL },
        { const_cast<char*>("-verbose:gc"), NULL },
        { const_cast<char*>(optionString.c_str()), NULL }
    };

    JavaVMInitArgs vm_args;
    vm_args.version = JNI_VERSION_1_6;
    vm_args.options = options;
    vm_args.nOptions = sizeof(options) / sizeof(JavaVMOption);
    assert(vm_args.nOptions == 3);

    this->JNIEnvironment = NULL;
    this->javaVM = NULL;

    int res = JNI_CreateJavaVM(&this->javaVM
                               , reinterpret_cast<void**>(&this->JNIEnvironment)
                               , &vm_args);

    if (JNI_OK != res)
    {
        throw std::runtime_error("JAVA_VM_EXCEPTION");
    }
}

void MWEJavaInterface::init_class()
{
    this->javaClass = this->JNIEnvironment
                          ->FindClass(std::string(this->javaClassName).c_str());

    if (NULL == this->javaClass)
    {
        throw std::runtime_error("JAVA_CLASS_EXCEPTION");
    }
}

void MWEJavaInterface::init_methods()
{
    this->IDconstructor = this->JNIEnvironment->GetMethodID(this->javaClass
                                                            , "<init>"
                                                            , "()V");

    this->IDsetString = this->JNIEnvironment
                            ->GetMethodID(this->javaClass
                                          , "setInputXML"
                                          , "(Ljava/lang/String;)V");

    this->IDgetString = this->JNIEnvironment
                            ->GetMethodID(this->javaClass
                                          , "getInputXML"
                                          , "()Ljava/lang/String;");
}

void MWEJavaInterface::j_constructor()
{
    this->javaClassInstance = this->JNIEnvironment
                                  ->NewObject(this->javaClass
                                              , this->IDconstructor);

    if (NULL == this->javaClassInstance)
    {
        throw std::runtime_error("JAVA_CONSTRUCTOR_EXCEPTION");
    }
}

void MWEJavaInterface::j_setString( std::string str)
{
    jstring argument = this->JNIEnvironment->NewStringUTF(str.c_str());

    this->JNIEnvironment->CallVoidMethod(this->javaClassInstance
                                         , this->IDsetString
                                         , argument);
}

std::string MWEJavaInterface::j_getString()
{

    jstring javaString
        = (jstring) this->JNIEnvironment
                        ->CallObjectMethod(this->javaClassInstance
                                           , this->IDgetString
                                           , 0);

    if (NULL == javaString)
    {
        throw std::runtime_error("JAVA_RETURN_EXCEPTION");
    }

    // jString to char*
    const char *nativeString = this->JNIEnvironment
                                   ->GetStringUTFChars(javaString, JNI_FALSE);

    std::string str(nativeString);

    this->JNIEnvironment->ReleaseStringUTFChars(javaString, nativeString);

    return str;
}

int main()
{
    MWEJavaInterface *jInterface = new MWEJavaInterface();

    jInterface->init_context();
    jInterface->init_class();
    jInterface->init_methods();
    jInterface->j_constructor();

    std::string test_str = jInterface->j_getString();
    std::cout << test_str << std::endl;
    std::cout << "everything runs great until now" << std::endl;

    jInterface->j_setString("test");
    test_str = jInterface->j_getString();
    std::cout << test_str << std::endl;
}