JNIUtil.h

Go to the documentation of this file.

 
#ifndef _JNIUtil_h_
#define _JNIUtil_h_
 
// ============================================================
#ifndef _JNI_EXPORT
    #ifdef _WIN32
        #define _JNI_EXPORT __declspec(dllimport)
    #else
        #define _JNI_EXPORT __attribute__((visibility("default")))
    #endif
#endif
 
// ============================================================
#ifndef NEED_JNIUTIL
    #if (defined(ANDROID) || defined(__ANDROID__) || defined(JNI_VERSION_1_1) || defined(JNIEXPORT) || defined(JNICALL))
        #define NEED_JNIUTIL 1
    #endif
#endif
 
#if NEED_JNIUTIL
#include <cstdlib>
#include <jni.h>
 
#if defined(__cplusplus) || defined(c_plusplus)
    #define _JNI_EXTERN_C extern "C"
#else
    #define _JNI_EXTERN_C
#endif
 
namespace JNIUtil {
 
// ============================================================
// wrapper
class _JNI_EXPORT JNIString {
public:
    JNIString(void);
    JNIString(JNIString const &ref);
    JNIString(const char *s);
    ~JNIString(void);
    JNIString &operator = (JNIString const &ref);
    JNIString &operator = (const char *s);
    const char *c_str(void) const;
    jsize length(void) const;
    operator const char * (void) const;
    JNIString &operator += (char c);
    JNIString &operator += (const char *s);
    void clear(void);
public:
    void *_d;
};
 
class JNIType;
class _JNI_EXPORT JNIParamTypeContainer {
public:
    JNIParamTypeContainer(void);
    ~JNIParamTypeContainer(void);
private:
    JNIParamTypeContainer(const JNIParamTypeContainer &ref);
    JNIParamTypeContainer &operator = (const JNIParamTypeContainer &ref);
public:
    JNIParamTypeContainer &add(const JNIType &paramType);
public:
    void remove(jint i);
    void removeAll(void);
public:
    jsize count(void) const;
    const JNIType &get(jint i) const;
public:
    void *_d;
};
 
// ============================================================
// common
extern _JNI_EXPORT bool JNIInit(JavaVM *javaVM, jint version = JNI_VERSION_1_1);

typedef JNIEnv *(*JNIGetJNIEnvCallback)(void);
extern _JNI_EXPORT bool JNIInit(JNIGetJNIEnvCallback callback);

extern _JNI_EXPORT JavaVM *JNIGetJavaVM(void);

extern _JNI_EXPORT jint JNIGetDesiredVersion(void);

extern _JNI_EXPORT JNIEnv *JNIGetJNIEnv(void);

extern _JNI_EXPORT void JNIConvertClassNameToClassSig(JNIString &ret, const char *className);
inline JNIString JNIConvertClassNameToClassSig(const char *className) {
    JNIString ret;
    JNIConvertClassNameToClassSig(ret, className);
    return ret;
}

extern _JNI_EXPORT void JNIConvertClassNameFromClassSig(JNIString &ret, const char *classSig);
inline JNIString JNIConvertClassNameFromClassSig(const char *className) {
    JNIString ret;
    JNIConvertClassNameFromClassSig(ret, className);
    return ret;
}

extern _JNI_EXPORT void JNIConvertClassNameForFindClass(JNIString &ret, const char *className);
inline JNIString JNIConvertClassNameForFindClass(const char *className) {
    JNIString ret;
    JNIConvertClassNameForFindClass(ret, className);
    return ret;
}

#define JNIConstructorName "<init>"
 
// ============================================================
// JNI types
class _JNI_EXPORT JNIType {
public:
    typedef enum {
        T_boolean, 
        T_byte, 
        T_char, 
        T_short, 
        T_int, 
        T_long, 
        T_float, 
        T_double, 
        T_void, 
        T_object, 
        T_array, 
    } Type;
 
public:
    JNIType(void);
    JNIType(JNIType::Type type,
            const char *classNameOrArrayElementTypeId = NULL);
    JNIType(const JNIType &ref);
    JNIType &operator = (const JNIType &ref);
 
public:
    void setType(JNIType::Type type,
                 const char *classNameOrArrayElementTypeId = NULL);
    JNIType::Type getType(void) const;
 
public:
    const char *getId(void) const;
 
public:
    static const JNIType &S_boolean(void);
    static const JNIType &S_byte(void);
    static const JNIType &S_char(void);
    static const JNIType &S_short(void);
    static const JNIType &S_int(void);
    static const JNIType &S_long(void);
    static const JNIType &S_float(void);
    static const JNIType &S_double(void);
    static const JNIType &S_void(void);
 
public:
    static inline JNIType S_object(const char *className) {
        return JNIType(JNIType::T_object, className);
    }
    static inline JNIType S_array(const JNIType &type) {
        return JNIType(JNIType::T_array, type.getId());
    }
 
public:
    static const JNIType &S_object_Class(void);
    static const JNIType &S_object_Object(void);
    static const JNIType &S_object_String(void);
public:
    static const JNIType &S_array_Class(void);
    static const JNIType &S_array_Object(void);
    static const JNIType &S_array_String(void);
 
private:
    JNIType::Type _type;
    JNIString *_id;
};
 
// ============================================================
// signature utilities
extern _JNI_EXPORT JNIString JNIGetMethodSig(
        const JNIType &returnType
        , const JNIParamTypeContainer &paramTypeList
        );
extern _JNI_EXPORT JNIString JNIGetMethodSig(
        const JNIType &returnType
        , const JNIType *paramTypeList
        , jsize paramCount
        );

#define _JNI_METHOD_DECLARE_BEGIN(OwnerClassId, ReturnType, MethodName, ...) \
    _JNI_EXTERN_C JNIEXPORT ReturnType JNICALL Java_##OwnerClassId##_##MethodName( \
        JNIEnv *jniEnv, jclass jniCls, ##__VA_ARGS__)
#define JNI_METHOD_DECLARE_BEGIN(OwnerClassId, ReturnType, MethodName, ...) \
    _JNI_METHOD_DECLARE_BEGIN(OwnerClassId, ReturnType, MethodName, ##__VA_ARGS__)
#define JNI_METHOD_DECLARE_END()

#define JNI_ONLOAD_ENTRY(paramJavaVM, paramReserved) \
    _JNI_EXTERN_C JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* paramJavaVM, void* paramReserved)
 
// ============================================================
// pointer converter
#ifndef JNIPointerUseLong
    #define JNIPointerUseLong 1
#endif
#ifndef JNIPointer
    #if JNIPointerUseLong
        #define JNIPointer jlong
    #else
        #define JNIPointer jbyteArray
    #endif
#endif
#ifndef JNIPointerInvalid
    #if JNIPointerUseLong
        #define JNIPointerInvalid 0
    #else
        #define JNIPointerInvalid NULL
    #endif
#endif
#ifndef JNIPointerJNIType
    #if JNIPointerUseLong
        #define JNIPointerJNIType JNIType::S_long()
    #else
        #define JNIPointerJNIType JNIType::S_array(JNIType::S_byte())
    #endif
#endif
 
jbyteArray _JNIConvertPointerToJNITypeAction(JNIEnv *jniEnv, void *p);
void *_JNIConvertPointerFromJNITypeAction(JNIEnv *jniEnv, jbyteArray d);
 
#if JNIPointerUseLong
    #define _JNIConvertPointerToJNIType(jniEnv, p) (JNIPointer)(p)
    #define _JNIConvertPointerFromJNIType(jniEnv, p) (void *)(p)
#else
    #define _JNIConvertPointerToJNIType(jniEnv, p) _JNIConvertPointerToJNITypeAction(jniEnv, p)
    #define _JNIConvertPointerFromJNIType(jniEnv, d) _JNIConvertPointerFromJNITypeAction(jniEnv, d)
#endif

#ifndef JNIConvertPointerToJNIType
    #define JNIConvertPointerToJNIType(jniEnv, p) _JNIConvertPointerToJNIType(jniEnv, p)
#endif
#ifndef JNIConvertPointerFromJNIType
    #define JNIConvertPointerFromJNIType(jniEnv, d) _JNIConvertPointerFromJNIType(jniEnv, d)
#endif
 
// ============================================================
// local/global ref cleaner
namespace JNIUtilPrivate {
    class _JNI_EXPORT LocalRefDel {
    public:
        LocalRefDel(jobject obj)
        : objSaved(obj)
        {
        }
        ~LocalRefDel(void) {
            if(this->objSaved) {
                JNIGetJNIEnv()->DeleteLocalRef(this->objSaved);
            }
        }
    public:
        jobject objSaved;
    };
    class _JNI_EXPORT GlobalRefDel {
    public:
        GlobalRefDel(jobject obj)
        : objSaved(obj)
        {
        }
        ~GlobalRefDel(void) {
            if(this->objSaved) {
                JNIGetJNIEnv()->DeleteGlobalRef(this->objSaved);
            }
        }
    public:
        jobject objSaved;
    };
    #define _JNIUtil_uniqueName(name) _JNIUtil_uniqueName2(name, __LINE__)
    #define _JNIUtil_uniqueName2(name, line) _JNIUtil_uniqueName3(name, line)
    #define _JNIUtil_uniqueName3(name, line) _JNIUtil_##name##_##line
} // namespace JNIUtilPrivate

#define JNILineDeleteLocalRef(obj_) \
    (JNIUtilPrivate::LocalRefDel(obj_).objSaved)
#define JNILineDeleteGlobalRef(obj_) \
    (JNIUtilPrivate::GlobalRefDel(obj_).objSaved)

#define JNIBlockedDeleteLocalRef(obj_) \
    JNIUtilPrivate::LocalRefDel _JNIUtil_uniqueName(jniRef)(obj_)
#define JNIBlockedDeleteGlobalRef(obj_) \
    JNIUtilPrivate::GlobalRefDel _JNIUtil_uniqueName(jniRef)(obj_)
 
} // namespace JNIUtil
#endif // #if NEED_JNIUTIL
 
#endif // #ifndef _JNIUtil_h_