fml::jni Namespace Reference

Classes
class	JavaObjectWeakGlobalRef
class	JavaRef
class	JavaRef< jobject >
struct	JNIDetach
class	ScopedJavaGlobalRef
class	ScopedJavaLocalFrame
class	ScopedJavaLocalRef

Functions
void	InitJavaVM (JavaVM *vm)
JNIEnv *	AttachCurrentThread ()
void	DetachFromVM ()
std::string	JavaStringToString (JNIEnv *env, jstring str)
ScopedJavaLocalRef< jstring >	StringToJavaString (JNIEnv *env, const std::string &u8_string)
std::vector< std::string >	StringArrayToVector (JNIEnv *env, jobjectArray array)
std::vector< std::string >	StringListToVector (JNIEnv *env, jobject list)
ScopedJavaLocalRef< jobjectArray >	VectorToStringArray (JNIEnv *env, const std::vector< std::string > &vector)
ScopedJavaLocalRef< jobjectArray >	VectorToBufferArray (JNIEnv *env, const std::vector< std::vector< uint8_t > > &vector)
bool	HasException (JNIEnv *env)
bool	ClearException (JNIEnv *env, bool silent)
bool	CheckException (JNIEnv *env)
std::string	GetJavaExceptionInfo (JNIEnv *env, jthrowable java_throwable)
ScopedJavaLocalRef< jobject >	GetRealObject (JNIEnv *env, jweak obj)

Variables
static JavaVM *	g_jvm = nullptr
static thread_local std::unique_ptr< JNIDetach >	tls_jni_detach
static const int	kDefaultLocalFrameCapacity = 16

Function Documentation

AttachCurrentThread()

JNIEnv * fml::jni::AttachCurrentThread

(

)

Definition at line 34 of file jni_util.cc.

                              {
  FML_DCHECK(g_jvm != nullptr)
      << "Trying to attach to current thread without calling InitJavaVM first.";
 
  JNIEnv* env = nullptr;
  if (g_jvm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_4) ==
      JNI_OK) {
    return env;
  }
 
  JavaVMAttachArgs args;
  args.version = JNI_VERSION_1_4;
  args.group = nullptr;
  // 16 is the maximum size for thread names on Android.
  char thread_name[16];
  int err = prctl(PR_GET_NAME, thread_name);
  if (err < 0) {
    args.name = nullptr;
  } else {
    args.name = thread_name;
  }
  [[maybe_unused]] jint ret = g_jvm->AttachCurrentThread(&env, &args);
  FML_DCHECK(JNI_OK == ret);
 
  FML_DCHECK(tls_jni_detach.get() == nullptr);
  tls_jni_detach.reset(new JNIDetach());
 
  return env;
}

CheckException()

bool fml::jni::CheckException

(

JNIEnv *

env

)

Definition at line 199 of file jni_util.cc.

                                 {
  if (!HasException(env)) {
    return true;
  }
 
  jthrowable exception = env->ExceptionOccurred();
  env->ExceptionClear();
  FML_LOG(ERROR) << fml::jni::GetJavaExceptionInfo(env, exception);
  env->DeleteLocalRef(exception);
  return false;
}

ClearException()

bool fml::jni::ClearException	(	JNIEnv *	env,
		bool	silent
	)

Definition at line 188 of file jni_util.cc.

                                              {
  if (!HasException(env)) {
    return false;
  }
  if (!silent) {
    env->ExceptionDescribe();
  }
  env->ExceptionClear();
  return true;
}

DetachFromVM()

void fml::jni::DetachFromVM

(

)

Definition at line 64 of file jni_util.cc.

                    {
  if (g_jvm) {
    g_jvm->DetachCurrentThread();
  }
}

GetJavaExceptionInfo()

std::string fml::jni::GetJavaExceptionInfo	(	JNIEnv *	env,
		jthrowable	java_throwable
	)

Definition at line 211 of file jni_util.cc.

                                                                       {
  ScopedJavaLocalRef<jclass> throwable_clazz(
      env, env->FindClass("java/lang/Throwable"));
  jmethodID throwable_printstacktrace = env->GetMethodID(
      throwable_clazz.obj(), "printStackTrace", "(Ljava/io/PrintStream;)V");
 
  // Create an instance of ByteArrayOutputStream.
  ScopedJavaLocalRef<jclass> bytearray_output_stream_clazz(
      env, env->FindClass("java/io/ByteArrayOutputStream"));
  jmethodID bytearray_output_stream_constructor =
      env->GetMethodID(bytearray_output_stream_clazz.obj(), "<init>", "()V");
  jmethodID bytearray_output_stream_tostring = env->GetMethodID(
      bytearray_output_stream_clazz.obj(), "toString", "()Ljava/lang/String;");
  ScopedJavaLocalRef<jobject> bytearray_output_stream(
      env, env->NewObject(bytearray_output_stream_clazz.obj(),
                          bytearray_output_stream_constructor));
 
  // Create an instance of PrintStream.
  ScopedJavaLocalRef<jclass> printstream_clazz(
      env, env->FindClass("java/io/PrintStream"));
  jmethodID printstream_constructor = env->GetMethodID(
      printstream_clazz.obj(), "<init>", "(Ljava/io/OutputStream;)V");
  ScopedJavaLocalRef<jobject> printstream(
      env, env->NewObject(printstream_clazz.obj(), printstream_constructor,
                          bytearray_output_stream.obj()));
 
  // Call Throwable.printStackTrace(PrintStream)
  env->CallVoidMethod(java_throwable, throwable_printstacktrace,
                      printstream.obj());
 
  // Call ByteArrayOutputStream.toString()
  ScopedJavaLocalRef<jstring> exception_string(
      env,
      static_cast<jstring>(env->CallObjectMethod(
          bytearray_output_stream.obj(), bytearray_output_stream_tostring)));
  if (ClearException(env)) {
    return "Java OOM'd in exception handling, check logcat";
  }
 
  return JavaStringToString(env, exception_string.obj());
}

GetRealObject()

ScopedJavaLocalRef< jobject > fml::jni::GetRealObject	(	JNIEnv *	env,
		jweak	obj
	)

Definition at line 45 of file jni_weak_ref.cc.

                                                                  {
  jobject real = NULL;
  if (obj) {
    real = env->NewLocalRef(obj);
    if (!real) {
      FML_DLOG(ERROR) << "The real object has been deleted!";
    }
  }
  return ScopedJavaLocalRef<jobject>(env, real);
}

HasException()

bool fml::jni::HasException

(

JNIEnv *

env

)

Definition at line 184 of file jni_util.cc.

                               {
  return env->ExceptionCheck() != JNI_FALSE;
}

InitJavaVM()

void fml::jni::InitJavaVM

(

JavaVM *

vm

)

Definition at line 29 of file jni_util.cc.

                            {
  FML_DCHECK(g_jvm == nullptr);
  g_jvm = vm;
}

JavaStringToString()

std::string fml::jni::JavaStringToString	(	JNIEnv *	env,
		jstring	str
	)

Definition at line 70 of file jni_util.cc.

                                                       {
  if (env == nullptr || str == nullptr) {
    return "";
  }
  const jchar* chars = env->GetStringChars(str, NULL);
  if (chars == nullptr) {
    return "";
  }
  std::u16string u16_string(reinterpret_cast<const char16_t*>(chars),
                            env->GetStringLength(str));
  std::string u8_string = Utf16ToUtf8(u16_string);
  env->ReleaseStringChars(str, chars);
  ASSERT_NO_EXCEPTION();
  return u8_string;
}

StringArrayToVector()

std::vector< std::string > fml::jni::StringArrayToVector	(	JNIEnv *	env,
		jobjectArray	array
	)

Definition at line 96 of file jni_util.cc.

                                                                          {
  std::vector<std::string> out;
  if (env == nullptr || array == nullptr) {
    return out;
  }
 
  jsize length = env->GetArrayLength(array);
 
  if (length == -1) {
    return out;
  }
 
  out.resize(length);
  for (jsize i = 0; i < length; ++i) {
    ScopedJavaLocalRef<jstring> java_string(
        env, static_cast<jstring>(env->GetObjectArrayElement(array, i)));
    out[i] = JavaStringToString(env, java_string.obj());
  }
 
  return out;
}

StringListToVector()

std::vector< std::string > fml::jni::StringListToVector	(	JNIEnv *	env,
		jobject	list
	)

Definition at line 118 of file jni_util.cc.

                                                                   {
  std::vector<std::string> out;
  if (env == nullptr || list == nullptr) {
    return out;
  }
 
  ScopedJavaLocalRef<jclass> list_clazz(env, env->FindClass("java/util/List"));
  FML_DCHECK(!list_clazz.is_null());
 
  jmethodID list_get =
      env->GetMethodID(list_clazz.obj(), "get", "(I)Ljava/lang/Object;");
  jmethodID list_size = env->GetMethodID(list_clazz.obj(), "size", "()I");
 
  jint size = env->CallIntMethod(list, list_size);
 
  if (size == 0) {
    return out;
  }
 
  out.resize(size);
  for (jint i = 0; i < size; ++i) {
    ScopedJavaLocalRef<jstring> java_string(
        env, static_cast<jstring>(env->CallObjectMethod(list, list_get, i)));
    out[i] = JavaStringToString(env, java_string.obj());
  }
 
  return out;
}

StringToJavaString()

ScopedJavaLocalRef< jstring > fml::jni::StringToJavaString	(	JNIEnv *	env,
		const std::string &	u8_string
	)

Definition at line 86 of file jni_util.cc.

                                                                           {
  std::u16string u16_string = Utf8ToUtf16(u8_string);
  auto result = ScopedJavaLocalRef<jstring>(
      env, env->NewString(reinterpret_cast<const jchar*>(u16_string.data()),
                          u16_string.length()));
  ASSERT_NO_EXCEPTION();
  return result;
}

VectorToBufferArray()

ScopedJavaLocalRef< jobjectArray > fml::jni::VectorToBufferArray	(	JNIEnv *	env,
		const std::vector< std::vector< uint8_t > > &	vector
	)

Definition at line 164 of file jni_util.cc.

                                                 {
  FML_DCHECK(env);
  ScopedJavaLocalRef<jclass> byte_buffer_clazz(
      env, env->FindClass("java/nio/ByteBuffer"));
  FML_DCHECK(!byte_buffer_clazz.is_null());
  jobjectArray java_array =
      env->NewObjectArray(vector.size(), byte_buffer_clazz.obj(), NULL);
  ASSERT_NO_EXCEPTION();
  for (size_t i = 0; i < vector.size(); ++i) {
    uint8_t* data = const_cast<uint8_t*>(vector[i].data());
    ScopedJavaLocalRef<jobject> item(
        env, env->NewDirectByteBuffer(reinterpret_cast<void*>(data),
                                      vector[i].size()));
    env->SetObjectArrayElement(java_array, i, item.obj());
  }
  return ScopedJavaLocalRef<jobjectArray>(env, java_array);
}

VectorToStringArray()

ScopedJavaLocalRef< jobjectArray > fml::jni::VectorToStringArray	(	JNIEnv *	env,
		const std::vector< std::string > &	vector
	)

Definition at line 147 of file jni_util.cc.

                                        {
  FML_DCHECK(env);
  ScopedJavaLocalRef<jclass> string_clazz(env,
                                          env->FindClass("java/lang/String"));
  FML_DCHECK(!string_clazz.is_null());
  jobjectArray java_array =
      env->NewObjectArray(vector.size(), string_clazz.obj(), NULL);
  ASSERT_NO_EXCEPTION();
  for (size_t i = 0; i < vector.size(); ++i) {
    ScopedJavaLocalRef<jstring> item = StringToJavaString(env, vector[i]);
    env->SetObjectArrayElement(java_array, i, item.obj());
  }
  return ScopedJavaLocalRef<jobjectArray>(env, java_array);
}

Variable Documentation

g_jvm

JavaVM* fml::jni::g_jvm = nullptr

static

Definition at line 18 of file jni_util.cc.

kDefaultLocalFrameCapacity

const int fml::jni::kDefaultLocalFrameCapacity = 16

static

Definition at line 13 of file scoped_java_ref.cc.

tls_jni_detach

thread_local std::unique_ptr<JNIDetach> fml::jni::tls_jni_detach

static

Definition at line 27 of file jni_util.cc.