local_ref<jstring> make_jstring(const char* utf8) {
if (!utf8) {
return {};
}
const auto env = internal::getEnv();
size_t len;
size_t modlen = detail::modifiedLength(reinterpret_cast<const uint8_t*>(utf8), &len);
jstring result;
if (modlen == len) {
// The only difference between utf8 and modifiedUTF8 is in encoding 4-byte UTF8 chars
// and '\0' that is encoded on 2 bytes.
//
// Since modifiedUTF8-encoded string can be no shorter than it's UTF8 conterpart we
// know that if those two strings are of the same length we don't need to do any
// conversion -> no 4-byte chars nor '\0'.
result = env->NewStringUTF(utf8);
} else {
auto modified = std::vector<char>(modlen + 1); // allocate extra byte for \0
detail::utf8ToModifiedUTF8(
reinterpret_cast<const uint8_t*>(utf8), len,
reinterpret_cast<uint8_t*>(modified.data()), modified.size());
result = env->NewStringUTF(modified.data());
}
FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
return adopt_local(result);
}
void JniFirebase::AuthWithPassword (const char* email, const char* password, long callback) {
auto env = getEnv();
if (!GetClass(env, "jnistub/AuthPasswordStub", &s_passwordClass)) {
return;
}
if (!GetMethod(env, s_passwordClass, "<init>",
"(Lcom/firebase/client/Firebase;JLjava/lang/String;Ljava/lang/String;)V", &s_passwordCtor)) {
return;
}
JOBJECT localRef = JOBJECT(env,
env->NewObject(s_passwordClass, s_passwordCtor, getJniObject(),
(jlong)callback,
(jstring)JSTRING(env, env->NewStringUTF(email)),
(jstring)JSTRING(env, env->NewStringUTF(password))));
}
void JniFirebase::AuthWithOAuthToken (const char* provider, const char* token, long callback) {
auto env = getEnv();
if (!GetClass(env, "jnistub/AuthOAuthStub", &s_oauthClass)) {
return;
}
if (!GetMethod(env, s_oauthClass, "<init>",
"(Lcom/firebase/client/Firebase;JLjava/lang/String;Ljava/lang/String;)V",
&s_oauthCtor)) {
return;
}
JOBJECT localRef = JOBJECT(env,
env->NewObject(s_oauthClass, s_oauthCtor, getJniObject(),
(jlong)callback,
(jstring)JSTRING(env, env->NewStringUTF(provider)),
(jstring)JSTRING(env, env->NewStringUTF(token))));
}
void _copyString(const std::string &value) {
auto env = spjni::getJniEnv();
auto clipboard = spjni::getService(spjni::Service::Clipboard, env);
auto clipboardClass = env->GetObjectClass(clipboard);
auto method = spjni::getMethodID(env, clipboardClass, "copyStringToClipboard", "(Ljava/lang/String;)V");
if (method) {
auto str = env->NewStringUTF(value.c_str());
env->CallVoidMethod(clipboard, method, str);
env->DeleteLocalRef(str);
}
}
void JniFirebase::SetString(const char *value) {
if (!m_firebase) {
return;
}
auto env = getEnv();
if (!GetMethod(env, s_firebaseClass, s_firebaseSetValueName, s_firebaseSetValueSig, &s_firebaseSetValue)) {
return;
}
env->CallVoidMethod(m_firebase, s_firebaseSetValue, (jstring)JSTRING(env, env->NewStringUTF(value)));
}
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);
}
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);
}
String::String(const char* string):
CharSequence(NewStringUTF(string))
{
Construct();
}
/*
* Class: java_lang_VMClassRegistry
* Method: getSystemPackages
* Signature: (I)[[Ljava/lang/String;
*/
JNIEXPORT jobjectArray JNICALL Java_java_lang_VMClassRegistry_getSystemPackages
(JNIEnv *jenv, jclass, jint len)
{
Global_Env* genv = VM_Global_State::loader_env;
ClassLoader* cl = static_cast<ClassLoader*>
(genv->bootstrap_class_loader);
Package_Table* ptab = cl->getPackageTable();
cl->Lock();
unsigned p_num = (unsigned)ptab->size();
if (p_num == (unsigned)len)
{
cl->Unlock();
return NULL;
}
const char ** pkgs = (const char **)STD_MALLOC(p_num * 2 * sizeof(char*));
size_t buf_len = 0;
unsigned index = 0;
for (Package_Table::const_iterator it = ptab->begin(), end = ptab->end();
it != end; ++it)
{
const char* name = pkgs[index++] = (*it).first->bytes;
pkgs[index++] = (*it).second->get_jar();
size_t name_len = (*it).first->len;
if (name_len > buf_len) {
buf_len = name_len;
}
}
cl->Unlock();
jclass string_class = struct_Class_to_java_lang_Class_Handle(genv->JavaLangString_Class);
static Class* aos = genv->LoadCoreClass("[Ljava/lang/String;");
jclass string_array_class = struct_Class_to_java_lang_Class_Handle(aos);
assert(string_class);
assert(string_array_class);
jobjectArray result = NewObjectArray(jenv, p_num, string_array_class, NULL);
if (result)
{
char* buf = (char*)STD_MALLOC(buf_len + 1);
p_num *= 2;
for (index = 0; index < p_num; )
{
jobjectArray pair = NewObjectArray(jenv, 2, string_class, NULL);
if (!pair) {
break;
}
SetObjectArrayElement(jenv, result, index/2, pair);
char* name = strcpy(buf, pkgs[index++]);
for (char* c = name; *c != '\0'; ++c) {
if (*c == '/') {
*c = '.';
}
}
jstring jname = NewStringUTF(jenv, name);
if (!jname) {
break;
}
SetObjectArrayElement(jenv, pair, 0, jname);
const char * jar = pkgs[index++];
if (jar) {
jstring js = NewStringUTF(jenv, jar);
if (!js) break;
SetObjectArrayElement(jenv, pair, 1, js);
}
}
STD_FREE(buf);
}
STD_FREE(pkgs);
assert(result || exn_raised());
return result;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
jstring CreateJStringFromSTDString(const std::string& in_string)
{
auto environment = JavaVirtualMachine::Get()->GetJNIEnvironment();
jstring output = environment->NewStringUTF(in_string.c_str());
return output;
}
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);
}
