ActivityState* ActivityState::create(ANativeActivity* activity)
{
JOP_ASSERT(ns_instance == nullptr, "There must only be one ActivityState!");
ns_instance.reset(new ActivityState);
ns_instance->nativeActivity = activity;
ANativeActivity_setWindowFlags(activity, AWINDOW_FLAG_KEEP_SCREEN_ON, AWINDOW_FLAG_KEEP_SCREEN_ON);
Thread::attachJavaThread(activity->vm, activity->env);
// Get the screen size
{
auto env = Thread::getCurrentJavaEnv();
if (!env)
{
JOP_DEBUG_ERROR("No current java environment, function \"" << __func__ << "\"");
return get();
}
jclass activityClass = env->GetObjectClass(activity->clazz);
jclass displayMetricsClass = env->FindClass("android/util/DisplayMetrics");
jmethodID displayMetricsInit = env->GetMethodID(displayMetricsClass, "<init>", "()V");
jobject displayMetricsObject = env->NewObject(displayMetricsClass, displayMetricsInit);
jmethodID getWindowManagerMethod = env->GetMethodID(activityClass, "getWindowManager", "()Landroid/view/WindowManager;");
jobject windowManagerObject = env->CallObjectMethod(activity->clazz, getWindowManagerMethod);
jclass windowManagerClass = env->FindClass("android/view/WindowManager");
jmethodID getDefaultDisplayMethod = env->GetMethodID(windowManagerClass, "getDefaultDisplay", "()Landroid/view/Display;");
jobject displayObject = env->CallObjectMethod(windowManagerObject, getDefaultDisplayMethod);
jclass displayClass = env->FindClass("android/view/Display");
jmethodID getMetricsMethod = env->GetMethodID(displayClass, "getMetrics", "(Landroid/util/DisplayMetrics;)V");
env->CallVoidMethod(displayObject, getMetricsMethod, displayMetricsObject);
jfieldID pixelsWidth = env->GetFieldID(displayMetricsClass, "widthPixels", "I");
jfieldID pixelsHeight = env->GetFieldID(displayMetricsClass, "heightPixels", "I");
ns_instance->screenSize.x = env->GetIntField(displayMetricsObject, pixelsWidth);
ns_instance->screenSize.y = env->GetIntField(displayMetricsObject, pixelsHeight);
//jmethodID getRefreshRateMethod = env->GetMethodID(displayClass, "getRefreshRate", "(Landroid/view/Display;)F");
ns_instance->screenRefreshRate = 60;//env->CallFloatMethod(displayObject, getRefreshRateMethod);
env->DeleteLocalRef(activityClass);
env->DeleteLocalRef(displayMetricsObject);
env->DeleteLocalRef(windowManagerObject);
env->DeleteLocalRef(windowManagerClass);
env->DeleteLocalRef(displayObject);
env->DeleteLocalRef(displayClass);
}
return get();
}
/*
* Retrieve string resource with a given name
* arguments:
* in: resourceName, name of string resource to retrieve
* return: string resource value, returns "" when there is no string resource with given name
*/
std::string JNIHelper::GetStringResource(const std::string& resourceName)
{
if (activity_ == NULL) {
LOGI("JNIHelper has not been initialized. Call init() to initialize the "
"helper");
return std::string("");
}
// Lock mutex
std::lock_guard<std::mutex> lock(mutex_);
JNIEnv *env = AttachCurrentThread();
jstring name = env->NewStringUTF(resourceName.c_str());
jstring ret = (jstring)
CallObjectMethod("getStringResource", "(Ljava/lang/String;)Ljava/lang/String;", name);
const char *resource = env->GetStringUTFChars(ret, NULL);
std::string s = std::string(resource);
env->ReleaseStringUTFChars(ret, resource);
env->DeleteLocalRef(ret);
env->DeleteLocalRef(name);
return s;
}
std::string NativeUserToken::JavaProxy::whoami() {
auto jniEnv = ::djinni::jniGetThreadEnv();
::djinni::JniLocalScope jscope(jniEnv, 10);
const auto& data = ::djinni::JniClass<::djinni_generated::NativeUserToken>::get();
auto jret = (jstring)jniEnv->CallObjectMethod(Handle::get().get(), data.method_whoami);
::djinni::jniExceptionCheck(jniEnv);
return ::djinni::String::toCpp(jniEnv, jret);
}
std::string NativeCoreApi::JavaProxy::GetDeviceOsApiVersion() {
auto jniEnv = ::djinni::jniGetThreadEnv();
::djinni::JniLocalScope jscope(jniEnv, 10);
const auto& data = ::djinni::JniClass<::djinni_generated::NativeCoreApi>::get();
auto jret = (jstring)jniEnv->CallObjectMethod(Handle::get().get(), data.method_getDeviceOsApiVersion);
::djinni::jniExceptionCheck(jniEnv);
return ::djinni::String::toCpp(jniEnv, jret);
}
std::optional<std::string> TestInterface::JavaProxy::get_string_ref() {
auto jniEnv = ::djinni::jniGetThreadEnv();
::djinni::JniLocalScope jscope(jniEnv, 10);
const auto& data = ::djinni::JniClass<::djinni_generated::TestInterface>::get();
auto jret = (jstring)jniEnv->CallObjectMethod(getGlobalRef(), data.method_getStringRef);
::djinni::jniExceptionCheck(jniEnv);
return ::djinni::Optional<std::optional, ::djinni::String>::toCpp(jniEnv, jret);
}
::ExternRecordWithDerivings NativeExternInterface2::JavaProxy::foo(const std::shared_ptr<::TestHelpers> & c_i) {
auto jniEnv = ::djinni::jniGetThreadEnv();
::djinni::JniLocalScope jscope(jniEnv, 10);
const auto& data = ::djinni::JniClass<::djinni_generated::NativeExternInterface2>::get();
auto jret = jniEnv->CallObjectMethod(getGlobalRef(), data.method_foo,
::djinni::get(::djinni_generated::NativeTestHelpers::fromCpp(jniEnv, c_i)));
::djinni::jniExceptionCheck(jniEnv);
return ::djinni_generated::NativeExternRecordWithDerivings::toCpp(jniEnv, jret);
}
JniFirebase* JniFirebase::Push() {
if (!m_firebase) {
return NULL;
}
auto env = getEnv();
if (!GetMethod(env, s_firebaseClass, s_firebasePushName, s_firebasePushSig, &s_firebasePush)) {
return NULL;
}
return new JniFirebase(env->CallObjectMethod(m_firebase, s_firebasePush));
}
static int GetSignHashCode()
{
JNIEnv* envPtr = GetEnvPtr();
jobject packageManager = CallObjectMethod
(
nativeActivity->clazz,
"getPackageManager",
"()Landroid/content/pm/PackageManager;"
).l;
jstring packageName = (jstring) CallObjectMethod
(
nativeActivity->clazz,
"getPackageName",
"()Ljava/lang/String;"
).l;
jobject packageInfo = CallObjectMethod
(
packageManager,
"getPackageInfo",
"(Ljava/lang/String;I)Landroid/content/pm/PackageInfo;",
packageName,
64
).l;
jclass packageInfoCls = (*envPtr)->GetObjectClass(envPtr, packageInfo);
jfieldID signaturesFid = (*envPtr)->GetFieldID
(
envPtr,
packageInfoCls,
"signatures",
"[Landroid/content/pm/Signature;"
);
jobjectArray signatureArr = (*envPtr)->GetObjectField (envPtr, packageInfo, signaturesFid);
jobject signature = (*envPtr)->GetObjectArrayElement(envPtr, signatureArr, 0);
return CallObjectMethod(signature, "hashCode", "()I").i;
}
::testsuite::ClientReturnedRecord NativeClientInterface::JavaProxy::get_record(int64_t c_record_id, const std::string & c_utf8string, const std::experimental::optional<std::string> & c_misc) {
auto jniEnv = ::djinni::jniGetThreadEnv();
::djinni::JniLocalScope jscope(jniEnv, 10);
const auto& data = ::djinni::JniClass<::djinni_generated::NativeClientInterface>::get();
auto jret = jniEnv->CallObjectMethod(Handle::get().get(), data.method_getRecord,
::djinni::get(::djinni::I64::fromCpp(jniEnv, c_record_id)),
::djinni::get(::djinni::String::fromCpp(jniEnv, c_utf8string)),
::djinni::get(::djinni::Optional<std::experimental::optional, ::djinni::String>::fromCpp(jniEnv, c_misc)));
::djinni::jniExceptionCheck(jniEnv);
return ::djinni_generated::NativeClientReturnedRecord::toCpp(jniEnv, jret);
}
uint64_t JniFirebase::GetAuthExpiration() {
auto env = getEnv();
if (!GetMethod(env, s_firebaseClass, "getAuth", "()Lcom.firebase.client.AuthData;",
&s_firebaseGetAuth)) {
return NULL;
}
JOBJECT authData = JOBJECT(env, env->CallObjectMethod(m_firebase, s_firebaseGetAuth));
JniAuth auth = JniAuth(authData);
return auth.GetAuthExpiration();
}
JniFirebase* JniFirebase::Root() {
if (!m_firebase) {
return NULL;
}
auto env = getEnv();
if (!GetMethod(env, s_firebaseClass, s_firebaseRootName, s_firebaseRootSig, &s_firebaseRoot)) {
return NULL;
}
JOBJECT rootFirebase = JOBJECT(env, env->CallObjectMethod(m_firebase, s_firebaseRoot));
return new JniFirebase(rootFirebase);
}
JniFirebase* JniFirebase::Child(const char *value) {
if (!m_firebase) {
return NULL;
}
auto env = getEnv();
if (!GetMethod(env, s_firebaseClass, s_firebaseChildName, s_firebaseChildSig, &s_firebaseChild)) {
return NULL;
}
JOBJECT childFirebase = JOBJECT(env, env->CallObjectMethod(m_firebase, s_firebaseChild, (jstring)JSTRING(env, env->NewStringUTF(value))));
return new JniFirebase(childFirebase);
}
std::string _getString() {
auto env = spjni::getJniEnv();
auto clipboard = spjni::getService(spjni::Service::Clipboard, env);
auto clipboardClass = env->GetObjectClass(clipboard);
auto method = spjni::getMethodID(env, clipboardClass, "getStringFromClipboard", "()Ljava/lang/String;");
if (method) {
auto strObj = (jstring)env->CallObjectMethod(clipboard, method);
if (strObj) {
return spjni::jStringToStdString(env, strObj);
}
}
return "";
}
cinder::fs::path CinderNativeActivity::getPicturesDirectory()
{
cinder::fs::path result;
auto jniEnv = JniHelper::Get()->AttachCurrentThread();
if( jniEnv ) {
jstring jstr = (jstring)jniEnv->CallObjectMethod( getInstance()->getJavaObject(), Java::getPicturesDirectory );
const char * c_str = jniEnv->GetStringUTFChars( jstr, nullptr );
result = std::string( c_str );
jniEnv->ReleaseStringUTFChars( jstr, c_str );
}
return result;
}
std::string _getCachesPath() {
auto env = spjni::getJniEnv();
auto activity = spjni::getActivity(env);
if (activity) {
auto activityClass = spjni::getClassID(env, activity);
if (auto getCachesPath = spjni::getMethodID(env, activityClass, "getCachesPath", "()Ljava/lang/String;")) {
if (auto strObj = (jstring)env->CallObjectMethod(activity, getCachesPath)) {
return spjni::jStringToStdString(env, strObj);
}
}
}
return _getWritablePath();
}
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;
}
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);
}
static void callJNIReturnString(const char* str, char* result)
{
auto env = gApp->activity->env;
auto vm = gApp->activity->vm;
auto obj = gApp->activity->clazz;
vm->AttachCurrentThread( &env, NULL );
auto clazz = env->GetObjectClass(obj);
jmethodID methodID = env->GetMethodID(clazz, str, "()[B");
auto array = (jbyteArray)env->CallObjectMethod(obj, methodID);
auto ptr = env->GetByteArrayElements(array, 0);
int len = env->GetArrayLength(array);
memcpy(result, ptr, len);
result[len] = '\0';
env->ReleaseByteArrayElements(array, ptr, JNI_ABORT);
vm->DetachCurrentThread();
}
char* JniFirebase::GetKey()
{
if (!m_firebase) {
return NULL;
}
auto env = getEnv();
if (!GetMethod(env, s_firebaseClass, s_firebaseGetKeyName, s_firebaseGetKeySig, &s_firebaseGetKey)) {
return NULL;
}
JSTRING java_string = JSTRING(env, (jstring)env->CallObjectMethod(m_firebase, s_firebaseGetKey));
if((jstring)java_string == NULL){
return NULL;
}
const char* utf_string = env->GetStringUTFChars(java_string, NULL);
#if _WIN64
char* result = _strdup(utf_string);
#else
char* result = strdup(utf_string);
#endif
env->ReleaseStringUTFChars(java_string, utf_string);
return result;
}
JString* JFile::getParent() {
JString* obj = new JString;
CallObjectMethod(obj, "getParent", "()Ljava/lang/String;");
return obj;
}
JString* JFile::getAbsolutePath() {
JString* obj = new JString;
CallObjectMethod(obj, "getAbsolutePath", "()Ljava/lang/String;");
return obj;
}
USER_OBJECT_
RS_JAVA(MethodConverter)(jobject obj, jclass type, JNIEnv *env, RSFromJavaConverter *converter)
{
int i = 0, k, n;
int numSlots;
USER_OBJECT_ ans, names;
const char *tmp;
jboolean isCopy;
jstring jval;
jclass klass;
jobject jsig, jobj;
ReflectanceMethodIDs *mids;
boolean isMethod;
jint modifier;
if(ModifierStringID == NULL)
initReflectanceMethods(env);
/* Determine whether we have a constructor or method
and set the method identifiers and number of slots
appropriately.
*/
isMethod = VMENV IsSameObject(env, type, VMENV FindClass(env, "java/lang/reflect/Method")) == JNI_TRUE;
if(isMethod) {
mids = &MethodIDs;
numSlots = 6;
} else {
mids = &ConstructorIDs;
numSlots = 5; /* Drop out the */
}
PROTECT(ans = NEW_LIST(numSlots));
PROTECT(names = NEW_CHARACTER(numSlots));
SET_VECTOR_ELT(ans, i, NEW_CHARACTER(1));
jval = VMENV CallObjectMethod(env, obj, mids->getName);
tmp = VMENV GetStringUTFChars(env, jval, &isCopy);
SET_STRING_ELT(VECTOR_ELT(ans, i), 0, COPY_TO_USER_STRING(tmp));
if(isCopy)
VMENV ReleaseStringUTFChars(env, jval, tmp);
SET_STRING_ELT(names, i, COPY_TO_USER_STRING("name"));
i++;
SET_VECTOR_ELT(ans, i, NEW_CHARACTER(1));
klass = VMENV CallObjectMethod(env, obj, mids->getClass);
tmp = getClassName(env, klass, &isCopy);
SET_STRING_ELT(VECTOR_ELT(ans, i), 0, COPY_TO_USER_STRING(tmp));
SET_STRING_ELT(names, i, COPY_TO_USER_STRING("Declaring class"));
i++;
jsig = VMENV CallObjectMethod(env, obj, mids->getParameters);
n = VMENV GetArrayLength(env, jsig);
SET_VECTOR_ELT(ans, i, NEW_CHARACTER(n));
for(k = 0; k < n ; k++) {
jobj = VMENV GetObjectArrayElement(env, jsig, k);
tmp = getClassName(env, jobj, &isCopy);
SET_STRING_ELT(VECTOR_ELT(ans, i), k, COPY_TO_USER_STRING(tmp));
}
SET_STRING_ELT(names, i, COPY_TO_USER_STRING("Parameters"));
i++;
SET_VECTOR_ELT(ans, i, NEW_INTEGER(1));
modifier = VMENV CallIntMethod(env, obj, mids->getModifiers);
INTEGER_DATA(VECTOR_ELT(ans, i))[0] = modifier;
SET_STRING_ELT(names, i, COPY_TO_USER_STRING("Modifiers"));
{
/* Now get the string that represents the modifier value.
Do this by calling the static method toString(int)
in the java.lang.reflect.Modifier class.
We assume we have initialized the ModifierStringID
method id earlier when getting all the method ids
for the reflectance classes.
*/
USER_OBJECT_ tmpr;
const char *modName;
jstring jmodName;
PROTECT(tmpr = NEW_CHARACTER(1));
jmodName = VMENV CallStaticObjectMethod(env, (jclass)VMENV FindClass(env, "java/lang/reflect/Modifier"), ModifierStringID, modifier);
if(jmodName != NULL_JAVA_OBJECT) {
modName = VMENV GetStringUTFChars(env, jmodName, &isCopy);
SET_STRING_ELT(tmpr, 0, COPY_TO_USER_STRING(modName));
}
SET_NAMES(VECTOR_ELT(ans, i), tmpr);
UNPROTECT(1);
}
i++;
jsig = VMENV CallObjectMethod(env, obj, mids->getExceptions);
n = VMENV GetArrayLength(env, jsig);
SET_VECTOR_ELT(ans, i, NEW_CHARACTER(n));
for(k = 0; k < n ; k++) {
jobj = VMENV GetObjectArrayElement(env, jsig, k);
tmp = getClassName(env, jobj, &isCopy);
SET_STRING_ELT(VECTOR_ELT(ans, i), k, COPY_TO_USER_STRING(tmp));
}
SET_STRING_ELT(names, i, COPY_TO_USER_STRING("Exceptions"));
i++;
if(isMethod) {
SET_VECTOR_ELT(ans, i, NEW_CHARACTER(1));
klass = VMENV CallObjectMethod(env, obj, mids->getReturnType);
tmp = getClassName(env, klass, &isCopy);
SET_VECTOR_ELT(VECTOR_ELT(ans, i), 0, COPY_TO_USER_STRING(tmp));
SET_STRING_ELT(names, i, COPY_TO_USER_STRING("Return type"));
i++;
}
SET_NAMES(ans, names);
/* Now set the class to be "JavaMethod" */
UNPROTECT(2);
return(ans);
}
