Home | History | Annotate | Download | only in android 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/android/jni_android.h"
      6 
      7 #include <map>
      8 
      9 #include "base/android/build_info.h"
     10 #include "base/android/jni_string.h"
     11 #include "base/lazy_instance.h"
     12 #include "base/logging.h"
     13 
     14 namespace {
     15 using base::android::GetClass;
     16 using base::android::MethodID;
     17 using base::android::ScopedJavaLocalRef;
     18 
     19 JavaVM* g_jvm = NULL;
     20 // Leak the global app context, as it is used from a non-joinable worker thread
     21 // that may still be running at shutdown. There is no harm in doing this.
     22 base::LazyInstance<base::android::ScopedJavaGlobalRef<jobject> >::Leaky
     23     g_application_context = LAZY_INSTANCE_INITIALIZER;
     24 
     25 std::string GetJavaExceptionInfo(JNIEnv* env, jthrowable java_throwable) {
     26   ScopedJavaLocalRef<jclass> throwable_clazz =
     27       GetClass(env, "java/lang/Throwable");
     28   jmethodID throwable_printstacktrace =
     29       MethodID::Get<MethodID::TYPE_INSTANCE>(
     30           env, throwable_clazz.obj(), "printStackTrace",
     31           "(Ljava/io/PrintStream;)V");
     32 
     33   // Create an instance of ByteArrayOutputStream.
     34   ScopedJavaLocalRef<jclass> bytearray_output_stream_clazz =
     35       GetClass(env, "java/io/ByteArrayOutputStream");
     36   jmethodID bytearray_output_stream_constructor =
     37       MethodID::Get<MethodID::TYPE_INSTANCE>(
     38           env, bytearray_output_stream_clazz.obj(), "<init>", "()V");
     39   jmethodID bytearray_output_stream_tostring =
     40       MethodID::Get<MethodID::TYPE_INSTANCE>(
     41           env, bytearray_output_stream_clazz.obj(), "toString",
     42           "()Ljava/lang/String;");
     43   ScopedJavaLocalRef<jobject> bytearray_output_stream(env,
     44       env->NewObject(bytearray_output_stream_clazz.obj(),
     45                      bytearray_output_stream_constructor));
     46 
     47   // Create an instance of PrintStream.
     48   ScopedJavaLocalRef<jclass> printstream_clazz =
     49       GetClass(env, "java/io/PrintStream");
     50   jmethodID printstream_constructor =
     51       MethodID::Get<MethodID::TYPE_INSTANCE>(
     52           env, printstream_clazz.obj(), "<init>",
     53           "(Ljava/io/OutputStream;)V");
     54   ScopedJavaLocalRef<jobject> printstream(env,
     55       env->NewObject(printstream_clazz.obj(), printstream_constructor,
     56                      bytearray_output_stream.obj()));
     57 
     58   // Call Throwable.printStackTrace(PrintStream)
     59   env->CallVoidMethod(java_throwable, throwable_printstacktrace,
     60       printstream.obj());
     61 
     62   // Call ByteArrayOutputStream.toString()
     63   ScopedJavaLocalRef<jstring> exception_string(
     64       env, static_cast<jstring>(
     65           env->CallObjectMethod(bytearray_output_stream.obj(),
     66                                 bytearray_output_stream_tostring)));
     67 
     68   return ConvertJavaStringToUTF8(exception_string);
     69 }
     70 
     71 }  // namespace
     72 
     73 namespace base {
     74 namespace android {
     75 
     76 JNIEnv* AttachCurrentThread() {
     77   DCHECK(g_jvm);
     78   JNIEnv* env = NULL;
     79   jint ret = g_jvm->AttachCurrentThread(&env, NULL);
     80   DCHECK_EQ(JNI_OK, ret);
     81   return env;
     82 }
     83 
     84 void DetachFromVM() {
     85   // Ignore the return value, if the thread is not attached, DetachCurrentThread
     86   // will fail. But it is ok as the native thread may never be attached.
     87   if (g_jvm)
     88     g_jvm->DetachCurrentThread();
     89 }
     90 
     91 void InitVM(JavaVM* vm) {
     92   DCHECK(!g_jvm);
     93   g_jvm = vm;
     94 }
     95 
     96 bool IsVMInitialized() {
     97   return g_jvm != NULL;
     98 }
     99 
    100 void InitApplicationContext(JNIEnv* env, const JavaRef<jobject>& context) {
    101   if (env->IsSameObject(g_application_context.Get().obj(), context.obj())) {
    102     // It's safe to set the context more than once if it's the same context.
    103     return;
    104   }
    105   DCHECK(g_application_context.Get().is_null());
    106   g_application_context.Get().Reset(context);
    107 }
    108 
    109 const jobject GetApplicationContext() {
    110   DCHECK(!g_application_context.Get().is_null());
    111   return g_application_context.Get().obj();
    112 }
    113 
    114 ScopedJavaLocalRef<jclass> GetClass(JNIEnv* env, const char* class_name) {
    115   jclass clazz = env->FindClass(class_name);
    116   CHECK(!ClearException(env) && clazz) << "Failed to find class " << class_name;
    117   return ScopedJavaLocalRef<jclass>(env, clazz);
    118 }
    119 
    120 template<MethodID::Type type>
    121 jmethodID MethodID::Get(JNIEnv* env,
    122                         jclass clazz,
    123                         const char* method_name,
    124                         const char* jni_signature) {
    125   jmethodID id = type == TYPE_STATIC ?
    126       env->GetStaticMethodID(clazz, method_name, jni_signature) :
    127       env->GetMethodID(clazz, method_name, jni_signature);
    128   CHECK(base::android::ClearException(env) || id) <<
    129       "Failed to find " <<
    130       (type == TYPE_STATIC ? "static " : "") <<
    131       "method " << method_name << " " << jni_signature;
    132   return id;
    133 }
    134 
    135 // If |atomic_method_id| set, it'll return immediately. Otherwise, it'll call
    136 // into ::Get() above. If there's a race, it's ok since the values are the same
    137 // (and the duplicated effort will happen only once).
    138 template<MethodID::Type type>
    139 jmethodID MethodID::LazyGet(JNIEnv* env,
    140                             jclass clazz,
    141                             const char* method_name,
    142                             const char* jni_signature,
    143                             base::subtle::AtomicWord* atomic_method_id) {
    144   COMPILE_ASSERT(sizeof(subtle::AtomicWord) >= sizeof(jmethodID),
    145                  AtomicWord_SmallerThan_jMethodID);
    146   subtle::AtomicWord value = base::subtle::Acquire_Load(atomic_method_id);
    147   if (value)
    148     return reinterpret_cast<jmethodID>(value);
    149   jmethodID id = MethodID::Get<type>(env, clazz, method_name, jni_signature);
    150   base::subtle::Release_Store(
    151       atomic_method_id, reinterpret_cast<subtle::AtomicWord>(id));
    152   return id;
    153 }
    154 
    155 // Various template instantiations.
    156 template jmethodID MethodID::Get<MethodID::TYPE_STATIC>(
    157     JNIEnv* env, jclass clazz, const char* method_name,
    158     const char* jni_signature);
    159 
    160 template jmethodID MethodID::Get<MethodID::TYPE_INSTANCE>(
    161     JNIEnv* env, jclass clazz, const char* method_name,
    162     const char* jni_signature);
    163 
    164 template jmethodID MethodID::LazyGet<MethodID::TYPE_STATIC>(
    165     JNIEnv* env, jclass clazz, const char* method_name,
    166     const char* jni_signature, base::subtle::AtomicWord* atomic_method_id);
    167 
    168 template jmethodID MethodID::LazyGet<MethodID::TYPE_INSTANCE>(
    169     JNIEnv* env, jclass clazz, const char* method_name,
    170     const char* jni_signature, base::subtle::AtomicWord* atomic_method_id);
    171 
    172 bool HasException(JNIEnv* env) {
    173   return env->ExceptionCheck() != JNI_FALSE;
    174 }
    175 
    176 bool ClearException(JNIEnv* env) {
    177   if (!HasException(env))
    178     return false;
    179   env->ExceptionDescribe();
    180   env->ExceptionClear();
    181   return true;
    182 }
    183 
    184 void CheckException(JNIEnv* env) {
    185   if (!HasException(env)) return;
    186 
    187   // Exception has been found, might as well tell breakpad about it.
    188   jthrowable java_throwable = env->ExceptionOccurred();
    189   if (!java_throwable) {
    190     // Do nothing but return false.
    191     CHECK(false);
    192   }
    193 
    194   // Clear the pending exception, since a local reference is now held.
    195   env->ExceptionDescribe();
    196   env->ExceptionClear();
    197 
    198   // Set the exception_string in BuildInfo so that breakpad can read it.
    199   // RVO should avoid any extra copies of the exception string.
    200   base::android::BuildInfo::GetInstance()->set_java_exception_info(
    201       GetJavaExceptionInfo(env, java_throwable));
    202 
    203   // Now, feel good about it and die.
    204   CHECK(false);
    205 }
    206 
    207 }  // namespace android
    208 }  // namespace base
    209