jni_android.cc revision 3551c9c881056c480085172ff9840cab31610854 
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#include "base/threading/platform_thread.h"
14
15namespace {
16using base::android::GetClass;
17using base::android::MethodID;
18using base::android::ScopedJavaLocalRef;
19
20struct MethodIdentifier {
21  const char* class_name;
22  const char* method;
23  const char* jni_signature;
24
25  bool operator<(const MethodIdentifier& other) const {
26    int r = strcmp(class_name, other.class_name);
27    if (r < 0) {
28      return true;
29    } else if (r > 0) {
30      return false;
31    }
32
33    r = strcmp(method, other.method);
34    if (r < 0) {
35      return true;
36    } else if (r > 0) {
37      return false;
38    }
39
40    return strcmp(jni_signature, other.jni_signature) < 0;
41  }
42};
43
44typedef std::map<MethodIdentifier, jmethodID> MethodIDMap;
45
46const base::subtle::AtomicWord kUnlocked = 0;
47const base::subtle::AtomicWord kLocked = 1;
48base::subtle::AtomicWord g_method_id_map_lock = kUnlocked;
49JavaVM* g_jvm = NULL;
50// Leak the global app context, as it is used from a non-joinable worker thread
51// that may still be running at shutdown. There is no harm in doing this.
52base::LazyInstance<base::android::ScopedJavaGlobalRef<jobject> >::Leaky
53    g_application_context = LAZY_INSTANCE_INITIALIZER;
54base::LazyInstance<MethodIDMap> g_method_id_map = LAZY_INSTANCE_INITIALIZER;
55
56std::string GetJavaExceptionInfo(JNIEnv* env, jthrowable java_throwable) {
57  ScopedJavaLocalRef<jclass> throwable_clazz =
58      GetClass(env, "java/lang/Throwable");
59  jmethodID throwable_printstacktrace =
60      MethodID::Get<MethodID::TYPE_INSTANCE>(
61          env, throwable_clazz.obj(), "printStackTrace",
62          "(Ljava/io/PrintStream;)V");
63
64  // Create an instance of ByteArrayOutputStream.
65  ScopedJavaLocalRef<jclass> bytearray_output_stream_clazz =
66      GetClass(env, "java/io/ByteArrayOutputStream");
67  jmethodID bytearray_output_stream_constructor =
68      MethodID::Get<MethodID::TYPE_INSTANCE>(
69          env, bytearray_output_stream_clazz.obj(), "<init>", "()V");
70  jmethodID bytearray_output_stream_tostring =
71      MethodID::Get<MethodID::TYPE_INSTANCE>(
72          env, bytearray_output_stream_clazz.obj(), "toString",
73          "()Ljava/lang/String;");
74  ScopedJavaLocalRef<jobject> bytearray_output_stream(env,
75      env->NewObject(bytearray_output_stream_clazz.obj(),
76                     bytearray_output_stream_constructor));
77
78  // Create an instance of PrintStream.
79  ScopedJavaLocalRef<jclass> printstream_clazz =
80      GetClass(env, "java/io/PrintStream");
81  jmethodID printstream_constructor =
82      MethodID::Get<MethodID::TYPE_INSTANCE>(
83          env, printstream_clazz.obj(), "<init>",
84          "(Ljava/io/OutputStream;)V");
85  ScopedJavaLocalRef<jobject> printstream(env,
86      env->NewObject(printstream_clazz.obj(), printstream_constructor,
87                     bytearray_output_stream.obj()));
88
89  // Call Throwable.printStackTrace(PrintStream)
90  env->CallVoidMethod(java_throwable, throwable_printstacktrace,
91      printstream.obj());
92
93  // Call ByteArrayOutputStream.toString()
94  ScopedJavaLocalRef<jstring> exception_string(
95      env, static_cast<jstring>(
96          env->CallObjectMethod(bytearray_output_stream.obj(),
97                                bytearray_output_stream_tostring)));
98
99  return ConvertJavaStringToUTF8(exception_string);
100}
101
102}  // namespace
103
104namespace base {
105namespace android {
106
107JNIEnv* AttachCurrentThread() {
108  DCHECK(g_jvm);
109  JNIEnv* env = NULL;
110  jint ret = g_jvm->AttachCurrentThread(&env, NULL);
111  DCHECK_EQ(JNI_OK, ret);
112  return env;
113}
114
115void DetachFromVM() {
116  // Ignore the return value, if the thread is not attached, DetachCurrentThread
117  // will fail. But it is ok as the native thread may never be attached.
118  if (g_jvm)
119    g_jvm->DetachCurrentThread();
120}
121
122void InitVM(JavaVM* vm) {
123  DCHECK(!g_jvm);
124  g_jvm = vm;
125}
126
127bool IsVMInitialized() {
128  return g_jvm != NULL;
129}
130
131void InitApplicationContext(const JavaRef<jobject>& context) {
132  DCHECK(g_application_context.Get().is_null());
133  g_application_context.Get().Reset(context);
134}
135
136const jobject GetApplicationContext() {
137  DCHECK(!g_application_context.Get().is_null());
138  return g_application_context.Get().obj();
139}
140
141ScopedJavaLocalRef<jclass> GetClass(JNIEnv* env, const char* class_name) {
142  jclass clazz = env->FindClass(class_name);
143  CHECK(!ClearException(env) && clazz) << "Failed to find class " << class_name;
144  return ScopedJavaLocalRef<jclass>(env, clazz);
145}
146
147bool HasClass(JNIEnv* env, const char* class_name) {
148  ScopedJavaLocalRef<jclass> clazz(env, env->FindClass(class_name));
149  if (!clazz.obj()) {
150    ClearException(env);
151    return false;
152  }
153  bool error = ClearException(env);
154  DCHECK(!error);
155  return true;
156}
157
158template<MethodID::Type type>
159jmethodID MethodID::Get(JNIEnv* env,
160                        jclass clazz,
161                        const char* method_name,
162                        const char* jni_signature) {
163  jmethodID id = type == TYPE_STATIC ?
164      env->GetStaticMethodID(clazz, method_name, jni_signature) :
165      env->GetMethodID(clazz, method_name, jni_signature);
166  CHECK(base::android::ClearException(env) || id) <<
167      "Failed to find " <<
168      (type == TYPE_STATIC ? "static " : "") <<
169      "method " << method_name << " " << jni_signature;
170  return id;
171}
172
173// If |atomic_method_id| set, it'll return immediately. Otherwise, it'll call
174// into ::Get() above. If there's a race, it's ok since the values are the same
175// (and the duplicated effort will happen only once).
176template<MethodID::Type type>
177jmethodID MethodID::LazyGet(JNIEnv* env,
178                            jclass clazz,
179                            const char* method_name,
180                            const char* jni_signature,
181                            base::subtle::AtomicWord* atomic_method_id) {
182  COMPILE_ASSERT(sizeof(subtle::AtomicWord) >= sizeof(jmethodID),
183                 AtomicWord_SmallerThan_jMethodID);
184  subtle::AtomicWord value = base::subtle::Acquire_Load(atomic_method_id);
185  if (value)
186    return reinterpret_cast<jmethodID>(value);
187  jmethodID id = MethodID::Get<type>(env, clazz, method_name, jni_signature);
188  base::subtle::Release_Store(
189      atomic_method_id, reinterpret_cast<subtle::AtomicWord>(id));
190  return id;
191}
192
193// Various template instantiations.
194template jmethodID MethodID::Get<MethodID::TYPE_STATIC>(
195    JNIEnv* env, jclass clazz, const char* method_name,
196    const char* jni_signature);
197
198template jmethodID MethodID::Get<MethodID::TYPE_INSTANCE>(
199    JNIEnv* env, jclass clazz, const char* method_name,
200    const char* jni_signature);
201
202template jmethodID MethodID::LazyGet<MethodID::TYPE_STATIC>(
203    JNIEnv* env, jclass clazz, const char* method_name,
204    const char* jni_signature, base::subtle::AtomicWord* atomic_method_id);
205
206template jmethodID MethodID::LazyGet<MethodID::TYPE_INSTANCE>(
207    JNIEnv* env, jclass clazz, const char* method_name,
208    const char* jni_signature, base::subtle::AtomicWord* atomic_method_id);
209
210jfieldID GetFieldID(JNIEnv* env,
211                    const JavaRef<jclass>& clazz,
212                    const char* field_name,
213                    const char* jni_signature) {
214  jfieldID field_id = env->GetFieldID(clazz.obj(), field_name, jni_signature);
215  CHECK(!ClearException(env) && field_id) << "Failed to find field " <<
216      field_name << " " << jni_signature;
217  return field_id;
218}
219
220bool HasField(JNIEnv* env,
221              const JavaRef<jclass>& clazz,
222              const char* field_name,
223              const char* jni_signature) {
224  jfieldID field_id = env->GetFieldID(clazz.obj(), field_name, jni_signature);
225  if (!field_id) {
226    ClearException(env);
227    return false;
228  }
229  bool error = ClearException(env);
230  DCHECK(!error);
231  return true;
232}
233
234jfieldID GetStaticFieldID(JNIEnv* env,
235                          const JavaRef<jclass>& clazz,
236                          const char* field_name,
237                          const char* jni_signature) {
238  jfieldID field_id =
239      env->GetStaticFieldID(clazz.obj(), field_name, jni_signature);
240  CHECK(!ClearException(env) && field_id) << "Failed to find static field " <<
241      field_name << " " << jni_signature;
242  return field_id;
243}
244
245jmethodID GetMethodIDFromClassName(JNIEnv* env,
246                                   const char* class_name,
247                                   const char* method,
248                                   const char* jni_signature) {
249  MethodIdentifier key;
250  key.class_name = class_name;
251  key.method = method;
252  key.jni_signature = jni_signature;
253
254  MethodIDMap* map = g_method_id_map.Pointer();
255  bool found = false;
256
257  while (base::subtle::Acquire_CompareAndSwap(&g_method_id_map_lock,
258                                              kUnlocked,
259                                              kLocked) != kUnlocked) {
260    base::PlatformThread::YieldCurrentThread();
261  }
262  MethodIDMap::const_iterator iter = map->find(key);
263  if (iter != map->end()) {
264    found = true;
265  }
266  base::subtle::Release_Store(&g_method_id_map_lock, kUnlocked);
267
268  // Addition to the map does not invalidate this iterator.
269  if (found) {
270    return iter->second;
271  }
272
273  ScopedJavaLocalRef<jclass> clazz(env, env->FindClass(class_name));
274  jmethodID id = MethodID::Get<MethodID::TYPE_INSTANCE>(
275      env, clazz.obj(), method, jni_signature);
276
277  while (base::subtle::Acquire_CompareAndSwap(&g_method_id_map_lock,
278                                              kUnlocked,
279                                              kLocked) != kUnlocked) {
280    base::PlatformThread::YieldCurrentThread();
281  }
282  // Another thread may have populated the map already.
283  std::pair<MethodIDMap::const_iterator, bool> result =
284      map->insert(std::make_pair(key, id));
285  DCHECK_EQ(id, result.first->second);
286  base::subtle::Release_Store(&g_method_id_map_lock, kUnlocked);
287
288  return id;
289}
290
291bool HasException(JNIEnv* env) {
292  return env->ExceptionCheck() != JNI_FALSE;
293}
294
295bool ClearException(JNIEnv* env) {
296  if (!HasException(env))
297    return false;
298  env->ExceptionDescribe();
299  env->ExceptionClear();
300  return true;
301}
302
303void CheckException(JNIEnv* env) {
304  if (!HasException(env)) return;
305
306  // Exception has been found, might as well tell breakpad about it.
307  jthrowable java_throwable = env->ExceptionOccurred();
308  if (!java_throwable) {
309    // Do nothing but return false.
310    CHECK(false);
311  }
312
313  // Clear the pending exception, since a local reference is now held.
314  env->ExceptionDescribe();
315  env->ExceptionClear();
316
317  // Set the exception_string in BuildInfo so that breakpad can read it.
318  // RVO should avoid any extra copies of the exception string.
319  base::android::BuildInfo::GetInstance()->set_java_exception_info(
320      GetJavaExceptionInfo(env, java_throwable));
321
322  // Now, feel good about it and die.
323  CHECK(false);
324}
325
326}  // namespace android
327}  // namespace base
328