java_utility.h

Go to the documentation of this file.

/********************************************************************************************
* Twitch Broadcasting SDK
*
* This software is supplied under the terms of a license agreement with Twitch Interactive, Inc. and
* may not be copied or used except in accordance with the terms of that agreement
* Copyright (c) 2012-2016 Twitch Interactive, Inc.
*********************************************************************************************/

#pragma once

#include "twitchsdk/core/types/errortypes.h"
#include "twitchsdk/core/mutex.h"

#include <vector>
#include <unordered_map>
#include <map>
#include <jni.h>


#define TTV_JNI_RETURN_ON_NULL(jni,ptr,err) { if ( (ptr) == nullptr) { ASSERT_ON_ERROR(err); return GetJavaInstance_ErrorCode(jni, err); } }
#define TTV_JNI_RETURN_ON_NOT_NULL(jni,ptr,err) { if ( (ptr) != nullptr) { ASSERT_ON_ERROR(err); return GetJavaInstance_ErrorCode(jni, err); } }
#define TTV_JNI_RETURN_ON_FALSE(jni,val,err) { if (!val) { return GetJavaInstance_ErrorCode(jni, err); } }


// Used to release local references when they variable goes out of scope.
#define AUTO_DELETE_LOCAL_REF(JENV, TYPE, VAR, VALUE) \
    TYPE VAR = static_cast<TYPE>(VALUE); \
    JavaLocalReferenceDeleter VAR##_Deleter(JENV, VAR, #VAR);

#define AUTO_DELETE_LOCAL_REF_NO_DECLARE(JENV, TYPE, VAR) \
    JavaLocalReferenceDeleter VAR##_Deleter(JENV, VAR, #VAR);


namespace ttv
{
    namespace binding
    {
        namespace java
        {
            extern JavaVM* gGlobalJavaVirtualMachine;   
            extern JNIEnv* gActiveJavaEnvironment;      
        
            class JavaLocalReferenceDeleter;
            class ScopedJavaUTFStringConverter;
            class ScopedJavaWcharStringConverter;
            class ScopedJavaEnvironmentCacher;
            class AutoJEnv;
            class GlobalJavaObjectReference;

            template <typename PROXY_TYPE>
            struct ProxyContext;

            template <typename PROXY_TYPE, typename LISTENER_TYPE>
            struct ProxyContextWithListener;

            template <typename NativeInstanceType, typename ContextType>
            class JavaNativeProxyRegistry;

            struct JavaClassInfo;

            bool CacheJavaVirtualMachine(JNIEnv* jEnv);

            bool LookupJavaClass(JNIEnv* jEnv, JavaClassInfo& info, const char* klass);
            bool LookupJavaMethod(JNIEnv* jEnv, JavaClassInfo& info, const char* method, const char* signature);
            bool LookupJavaStaticMethod(JNIEnv* jEnv, JavaClassInfo& info, const char* method, const char* signature);
            bool LookupJavaField(JNIEnv* jEnv, JavaClassInfo& info, const char* field, const char* signature);

            JavaClassInfo& GetJavaClassInfo_Boolean(JNIEnv* jEnv);
            JavaClassInfo& GetJavaClassInfo_Integer(JNIEnv* jEnv);
            JavaClassInfo& GetJavaClassInfo_Long(JNIEnv* jEnv);
            JavaClassInfo& GetJavaClassInfo_Float(JNIEnv* jEnv);
            JavaClassInfo& GetJavaClassInfo_Double(JNIEnv* jEnv);
            JavaClassInfo& GetJavaClassInfo_String(JNIEnv* jEnv);
            JavaClassInfo& GetJavaClassInfo_Charset(JNIEnv* jEnv);
            JavaClassInfo& GetJavaClassInfo_HashSet(JNIEnv* jEnv);
            JavaClassInfo& GetJavaClassInfo_HashMap(JNIEnv* jEnv);

            jobject GetJavaInstance_Boolean(JNIEnv* jEnv, bool value);
            jobject GetJavaInstance_Integer(JNIEnv* jEnv, int32_t value);
            jobject GetJavaInstance_Integer(JNIEnv* jEnv, uint32_t value);
            jobject GetJavaInstance_Long(JNIEnv* jEnv, uint64_t value);
            jobject GetJavaInstance_Long(JNIEnv* jEnv, int64_t value);
            jobject GetJavaInstance_Float(JNIEnv* jEnv, float value);
            jobject GetJavaInstance_Double(JNIEnv* jEnv, double value);

            jstring GetJavaInstance_StringWithEncoding(JNIEnv* jEnv, const std::string& str);
            jstring GetJavaInstance_String(JNIEnv* jEnv, const char* str);
            jstring GetJavaInstance_String(JNIEnv* jEnv, const std::string& str);

            jobject GetJavaInstance_EnumValue(JNIEnv* jEnv, const ttv::EnumValue& value);
            jobjectArray GetJavaInstance_EnumValueArray(JNIEnv* jEnv, const std::vector<ttv::EnumValue>& arr);
            jobject GetJavaInstance_ErrorCode(JNIEnv* jEnv, TTV_ErrorCode err);
            jobjectArray GetJavaInstance_StringArray(JNIEnv* jEnv, const std::vector<std::string>& arr);
            jobject GetJavaInstance_StringHashMap(JNIEnv* jEnv, const std::map<std::string, std::string>& map);
            jobject GetJavaInstance_ResultContainer(JNIEnv* jEnv);
            jobject GetJavaInstance_GetResultFromResultContainer(JNIEnv* jEnv, jobject jResultContainer);

            void GetNativeInstance_HttpRequestResult(JNIEnv* jEnv, jobject jRequestResult, uint& statusCode, std::map<std::string, std::string>& resultHeaders, std::vector<char>& response);
            void GetNativeInstance_StringVector(JNIEnv* jEnv, jobjectArray jArray, std::vector<std::string>& result);

            void SetResultContainerResult(JNIEnv* jEnv, jobject jResultContainer, jobject jResult);

            jobjectArray GetJavaInstance_Array(JNIEnv* jEnv, JavaClassInfo& javaArrayTypeClassInfo, const uint32_t size, std::function<jobject(uint32_t index)> entryFunc);

            void GetNativeFromJava_ByteArray(JNIEnv* jEnv, jbyteArray jSource, std::vector<uint8_t>& dest);

            void LoadAllUtilityJavaClassInfo(JNIEnv* jEnv);

            template<typename... ArgTypes>
            std::function<void(ArgTypes...)> CreateJavaCallbackWrapper(JNIEnv* jEnv, jobject jCallback, JavaClassInfo& callbackInfo);

            template <typename ContainerType, typename KVTransformerType>
            jobject GetJavaInstance_HashMap(JNIEnv* jEnv, const ContainerType& container, const KVTransformerType& transformer);

            template <typename T>
            jobject GetJavaInstance_SimpleEnum(JNIEnv* jEnv, JavaClassInfo& info, T val);

            template <typename T>
            T GetNativeFromJava_SimpleEnum(JNIEnv* jEnv, JavaClassInfo& info, jobject jEnumValue, T defaultValue);
        }
    }
}


class ttv::binding::java::JavaLocalReferenceDeleter
{
public:
    JavaLocalReferenceDeleter(JNIEnv* jEnv, jobject jObject, const char* name);
    ~JavaLocalReferenceDeleter();

protected:
    JNIEnv* mjEnv;
    jobject mObject;
    const char* mName;
};


class ttv::binding::java::ScopedJavaUTFStringConverter
{
public:
    ScopedJavaUTFStringConverter(JNIEnv* jEnv, jstring jstr);
    ~ScopedJavaUTFStringConverter();

    const char* GetNativeString();
    int GetCharacterLength() const { return mCharacterLength; }
    int GetByteLength() const { return mByteLength; }

    operator const char*() { return GetNativeString(); }
    operator std::string() { return GetNativeString(); }

protected:
    JNIEnv* mjEnv;
    jstring mJavaString;
    const char* mNativeString;
    int mCharacterLength;
    int mByteLength;
};


class ttv::binding::java::ScopedJavaWcharStringConverter
{
public:
    ScopedJavaWcharStringConverter(JNIEnv* jEnv, jstring jstr);

    const wchar_t* GetNativeString() const;

protected:
    JNIEnv* mjEnv;
    jstring mJavaString;
    const wchar_t* mNativeString;
    std::wstring mSTDWideString;
};


class ttv::binding::java::ScopedJavaEnvironmentCacher
{
public:
    ScopedJavaEnvironmentCacher(JNIEnv* jenv);
    ~ScopedJavaEnvironmentCacher();

    static int GetMinLocalReferenceTableCapacity();

protected:
    static int mCacheCount;
};


class ttv::binding::java::AutoJEnv
{
public:
    AutoJEnv();
    AutoJEnv(JavaVM* jvm);
    ~AutoJEnv();

    JavaVM* GetJvm() { return mJvm; }

    JNIEnv* operator->();
    operator JNIEnv*();

private:
    bool Lock();
    void Unlock();

    JavaVM* mJvm;
    JNIEnv* mJEnv;
    bool mNeedsDetach;
};


class ttv::binding::java::GlobalJavaObjectReference
{
public:
    GlobalJavaObjectReference();
    virtual ~GlobalJavaObjectReference();

    bool Bind(JNIEnv* jEnv, jobject jLocalObject);
    void Release();

    jobject GetInstance() const { return mObject; }
    jbyteArray GetInstanceAsByteArray() const { return static_cast<jbyteArray>(mObject); }

protected:
    jobject mObject;
};


template <typename PROXY_TYPE>
struct ttv::binding::java::ProxyContext
{
    std::shared_ptr<PROXY_TYPE> instance;
};

template <typename PROXY_TYPE, typename LISTENER_TYPE>
struct ttv::binding::java::ProxyContextWithListener
{
    std::shared_ptr<PROXY_TYPE> instance;
    std::shared_ptr<LISTENER_TYPE> nativeListener;
};


template <typename NativeInstanceType, typename ContextType>
class ttv::binding::java::JavaNativeProxyRegistry
{
public:
    void Register(const std::shared_ptr<NativeInstanceType>& nativeInstance, const std::shared_ptr<ContextType>& nativeContext, jobject javaInstance)
    {
        if (mMutex == nullptr)
        {
            CreateMutex(mMutex);
        }

        AutoJEnv jEnv;
    
        auto entry = std::make_shared<Entry>();
        entry->nativeInstance = nativeInstance;
        entry->nativeContext = nativeContext;
        entry->javaInstance.Bind(jEnv, javaInstance);

        ttv::AutoMutex mutex(mMutex);
        mRegistry.push_back(entry);
    }

    void Unregister(jlong jNativePointer)
    {
        Unregister(reinterpret_cast<NativeInstanceType*>(jNativePointer));
    }

    void Unregister(NativeInstanceType* nativeInstance)
    {
        if (mMutex == nullptr)
        {
            return;
        }

        ttv::AutoMutex mutex(mMutex);

        for (auto iter = mRegistry.begin(); iter != mRegistry.end(); ++iter)
        {
            auto& entry = *iter;

            if (entry->nativeInstance.get() == nativeInstance)
            {
                mRegistry.erase(iter);
                return;
            }
        }
    }

    void Unregister(jobject javaInstance)
    {
        if (mMutex == nullptr)
        {
            return;
        }

        ttv::AutoMutex mutex(mMutex);
        AutoJEnv jEnv;

        for (auto iter = mRegistry.begin(); iter != mRegistry.end(); ++iter)
        {
            auto& entry = *iter;

            if (jEnv->IsSameObject(javaInstance, entry->javaInstance.GetInstance()))
            {
                mRegistry.erase(iter);
                return;
            }
        }
    }

    std::shared_ptr<NativeInstanceType> LookupNativeInstance(jobject javaInstance)
    {
        if (mMutex == nullptr)
        {
            return nullptr;
        }

        ttv::AutoMutex mutex(mMutex);
        AutoJEnv jEnv;

        for (const auto& entry : mRegistry)
        {
            if (jEnv->IsSameObject(javaInstance, entry->javaInstance.GetInstance()))
            {
                return entry->nativeInstance;
            }
        }

        return nullptr;
    }

    std::shared_ptr<ContextType> LookupNativeContext(jobject javaInstance)
    {
        if (mMutex == nullptr)
        {
            return nullptr;
        }

        ttv::AutoMutex mutex(mMutex);
        AutoJEnv jEnv;

        for (const auto& entry : mRegistry)
        {
            if (jEnv->IsSameObject(javaInstance, entry->javaInstance.GetInstance()))
            {
                return entry->nativeContext;
            }
        }

        return nullptr;
    }

    std::shared_ptr<ContextType> LookupNativeContext(jlong nativeInstance)
    {
        if (mMutex == nullptr)
        {
            return nullptr;
        }

        ttv::AutoMutex mutex(mMutex);
        AutoJEnv jEnv;

        for (const auto& entry : mRegistry)
        {
            if (reinterpret_cast<NativeInstanceType*>(nativeInstance) == entry->nativeInstance.get())
            {
                return entry->nativeContext;
            }
        }

        return nullptr;
    }

private:
    struct Entry
    {
        std::shared_ptr<NativeInstanceType> nativeInstance;
        std::shared_ptr<ContextType> nativeContext;
        GlobalJavaObjectReference javaInstance;
    };

    std::vector<std::shared_ptr<Entry>> mRegistry;
    std::shared_ptr<ttv::IMutex> mMutex;
};


struct ttv::binding::java::JavaClassInfo
{
    jclass klass;
    std::unordered_map<std::string, jmethodID> methods; 
    std::unordered_map<std::string, jmethodID> staticMethods; 
    std::unordered_map<std::string, jfieldID> fields;
};


template<typename... ArgTypes>
std::function<void(ArgTypes...)> ttv::binding::java::CreateJavaCallbackWrapper(JNIEnv* jEnv, jobject jCallback, JavaClassInfo& callbackInfo)
{
    auto callbackReference = std::make_shared<GlobalJavaObjectReference>();
    callbackReference->Bind(jEnv, jCallback);

    // Capturing callbackInfo by reference here is fine because it is global
    // and immutable.
    return [callbackReference, &callbackInfo](ArgTypes... args)
    {
        auto callback = callbackReference->GetInstance();

        if (callback != nullptr)
        {
            gActiveJavaEnvironment->CallVoidMethod(callback, callbackInfo.methods["invoke"], args...);
        }
    };
};


template <typename ContainerType, typename KVTransformerType>
jobject ttv::binding::java::GetJavaInstance_HashMap(JNIEnv* jEnv, const ContainerType& container, const KVTransformerType& transformer)
{
    JavaClassInfo& hashMapInfo = GetJavaClassInfo_HashMap(jEnv);
    jobject jHashMap = jEnv->NewObject(hashMapInfo.klass, hashMapInfo.methods["<init>"]);

    for (const auto& pair : container)
    {
        auto jPair = transformer(pair);
        AUTO_DELETE_LOCAL_REF(jEnv, jobject, jKey, jPair.first);
        AUTO_DELETE_LOCAL_REF(jEnv, jobject, jValue, jPair.second);

        jEnv->CallObjectMethod(jHashMap, hashMapInfo.methods["put"], jKey, jValue);
    }

    return jHashMap;
}


template <typename T>
jobject ttv::binding::java::GetJavaInstance_SimpleEnum(JNIEnv* jEnv, JavaClassInfo& info, T val)
{
    return jEnv->CallStaticObjectMethod(info.klass, info.staticMethods["lookupValue"], static_cast<jint>(val));
}


template <typename T>
T ttv::binding::java::GetNativeFromJava_SimpleEnum(JNIEnv* jEnv, JavaClassInfo& info, jobject jEnumValue, T defaultValue)
{
    if (jEnumValue == nullptr)
    {
        return defaultValue;
    }

    return static_cast<T>( jEnv->CallIntMethod(jEnumValue, info.methods["getValue"]) );
}