//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
JavaStaticClass::JavaStaticClass(const JavaStaticClassDef& in_javaStaticClassDef)
{
auto environment = JavaVirtualMachine::Get()->GetJNIEnvironment();
//Get the class
m_className = in_javaStaticClassDef.GetClassName();
jclass jClass = environment->FindClass(m_className.c_str());
CS_ASSERT(jClass != nullptr, "Could not find Java class: '" + m_className + "'");
m_javaClass = static_cast<jclass>(environment->NewGlobalRef(jClass));
environment->DeleteLocalRef(jClass);
//setup the method references
for (const auto& method : in_javaStaticClassDef.GetMethods())
{
CS_ASSERT(m_methods.find(method.first) == m_methods.end(), "Method '" + method.first + "' has already been added to Java static class '" + m_className + "'");
MethodInfo info;
info.m_returnType = JavaMethodSignature::CalcReturnType(method.second);
info.m_numArguments = JavaMethodSignature::CalcNumArguments(method.second);
info.m_methodId = environment->GetStaticMethodID(m_javaClass, method.first.c_str(), method.second.c_str());
CS_ASSERT(info.m_methodId != nullptr, "Could not find method '" + method.first + "' in Java static class '" + m_className + "'");
m_methods.emplace(method.first, info);
}
}
alias_ref<jclass> findClassStatic(const char* name) {
const auto env = internal::getEnv();
auto cls = env->FindClass(name);
FACEBOOK_JNI_THROW_EXCEPTION_IF(!cls);
auto leaking_ref = (jclass)env->NewGlobalRef(cls);
FACEBOOK_JNI_THROW_EXCEPTION_IF(!leaking_ref);
return wrap_alias(leaking_ref);
}
JniFirebase::JniFirebase(jobject object) {
auto env = getEnv();
if (env == NULL) {
m_firebase = NULL;
}
else {
m_firebase = env->NewGlobalRef(object);
}
}
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *pjvm, void *reserved) {
ILOG("JNI_OnLoad");
gJvm = pjvm; // cache the JavaVM pointer
auto env = getEnv();
//replace with one of your classes in the line below
auto randomClass = env->FindClass("org/ppsspp/ppsspp/NativeActivity");
jclass classClass = env->GetObjectClass(randomClass);
auto classLoaderClass = env->FindClass("java/lang/ClassLoader");
auto getClassLoaderMethod = env->GetMethodID(classClass, "getClassLoader",
"()Ljava/lang/ClassLoader;");
gClassLoader = env->NewGlobalRef(env->CallObjectMethod(randomClass, getClassLoaderMethod));
gFindClassMethod = env->GetMethodID(classLoaderClass, "findClass",
"(Ljava/lang/String;)Ljava/lang/Class;");
return JNI_VERSION_1_6;
}
JniFirebase::JniFirebase(const char* path) {
auto env = getEnv();
if (!GetClass(env, "com/firebase/client/Firebase", &s_firebaseClass)) {
return;
}
if (!GetMethod(env, s_firebaseClass, "<init>", "(Ljava/lang/String;)V", &s_firebaseCtor)) {
return;
}
JOBJECT localRef = JOBJECT(env, env->NewObject(s_firebaseClass, s_firebaseCtor,
(jstring)JSTRING(env, env->NewStringUTF(path))));
m_firebase = env->NewGlobalRef(localRef);
}
static jclass
init_jni_bindings(JNIEnv *jenv) {
jclass class =
(*jenv)->NewGlobalRef(jenv,
(*jenv)->FindClass(jenv,
"android/media/AudioTrack"));
at.constructor = (*jenv)->GetMethodID(jenv, class, "<init>", "(IIIIII)V");
at.flush = (*jenv)->GetMethodID(jenv, class, "flush", "()V");
at.pause = (*jenv)->GetMethodID(jenv, class, "pause", "()V");
at.play = (*jenv)->GetMethodID(jenv, class, "play", "()V");
at.setvol = (*jenv)->GetMethodID(jenv, class, "setStereoVolume", "(FF)I");
at.stop = (*jenv)->GetMethodID(jenv, class, "stop", "()V");
at.write = (*jenv)->GetMethodID(jenv, class, "write", "([BII)I");
at.getpos = (*jenv)->GetMethodID(jenv, class, "getPlaybackHeadPosition", "()I");
return class;
}
void JniFirebase::SetJson(const char *value) {
auto env = getEnv();
if (s_objectMapperInstance == NULL) {
lock<std::mutex> lock(s_objectMapperLock);
if (s_objectMapperInstance == NULL) {
if (!GetClass(env, "java/util/HashMap", &s_objectClass)) {
return;
}
if (!GetClass(env, s_objectMapperClassName, &s_objectMapperClass)) {
return;
}
jmethodID ctor = NULL;
if (!GetMethod(env, s_objectMapperClass, "<init>", "()V", &ctor))
{
return;
}
if (!GetMethod(env, s_objectMapperClass, s_objectMapperReadValueName, s_objectMapperReadValueSig, &s_objectMapperReadValue)) {
return;
}
JOBJECT localRef = JOBJECT(env, env->NewObject(s_objectMapperClass, ctor));
s_objectMapperInstance = env->NewGlobalRef(localRef);
}
}
JOBJECT localValue = JOBJECT(env,
env->CallObjectMethod(s_objectMapperInstance, s_objectMapperReadValue,
(jstring)JSTRING(env, env->NewStringUTF(value)), s_objectClass));
if (env->ExceptionCheck() == JNI_TRUE) {
SetString(GetJNIExceptionDescription(env, env->ExceptionOccurred()));
return;
}
if (!GetMethod(env, s_firebaseClass, s_firebaseSetValueName, s_firebaseSetValueSig, &s_firebaseSetValue)) {
return;
}
env->CallVoidMethod(m_firebase, s_firebaseSetValue, (jobject)localValue);
}
JniChildEventStub::JniChildEventStub(JniFirebase* firebase, jlong cookie) {
auto env = getEnv();
if (!GetClass(env, s_stubClassName, &s_stubClass)) {
return;
}
if (!GetMethod(env, s_stubClass, s_stubCtorName, s_stubCtorSig, &s_stubCtor)) {
return;
}
if (!GetMethod(env, s_stubClass, s_stubReleaseName, s_stubReleaseSig, &s_stubRelease)) {
return;
}
JOBJECT localRef = JOBJECT(env,
env->NewObject(s_stubClass, s_stubCtor, firebase->getJniObject(),
cookie));
m_stub = env->NewGlobalRef(localRef);
}
F(const F& other)
{
auto jniEnv = djinni::jniGetThreadEnv();
_runnable = other._runnable ? jniEnv->NewGlobalRef(other._runnable) : nullptr;
}
