Move /webrtc/api/android files to /webrtc/sdk/android
I decided to make one webrtc/sdk/android/BUILD.gn for both tests and Java/jni src. External dependencies needs to be updated after this CL. Future work is required to clean up the Android api and move implementation details to /webrtc/sdk/android/src. BUG=webrtc:5882,webrtc:6804 NOPRESUBMIT=True Review-Url: https://codereview.webrtc.org/2547483003 Cr-Commit-Position: refs/heads/master@{#15443}
This commit is contained in:
magjed
350
webrtc/sdk/android/src/jni/jni_helpers.cc
Normal file
350
webrtc/sdk/android/src/jni/jni_helpers.cc
Normal file
@ -0,0 +1,350 @@
|
||||
/*
|
||||
* Copyright 2015 The WebRTC project authors. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license
|
||||
* that can be found in the LICENSE file in the root of the source
|
||||
* tree. An additional intellectual property rights grant can be found
|
||||
* in the file PATENTS. All contributing project authors may
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
#include "webrtc/sdk/android/src/jni/jni_helpers.h"
|
||||
|
||||
#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
|
||||
|
||||
#include <asm/unistd.h>
|
||||
#include <sys/prctl.h>
|
||||
#include <sys/syscall.h>
|
||||
#include <unistd.h>
|
||||
|
||||
namespace webrtc_jni {
|
||||
|
||||
static JavaVM* g_jvm = nullptr;
|
||||
|
||||
static pthread_once_t g_jni_ptr_once = PTHREAD_ONCE_INIT;
|
||||
|
||||
// Key for per-thread JNIEnv* data. Non-NULL in threads attached to |g_jvm| by
|
||||
// AttachCurrentThreadIfNeeded(), NULL in unattached threads and threads that
|
||||
// were attached by the JVM because of a Java->native call.
|
||||
static pthread_key_t g_jni_ptr;
|
||||
|
||||
JavaVM *GetJVM() {
|
||||
RTC_CHECK(g_jvm) << "JNI_OnLoad failed to run?";
|
||||
return g_jvm;
|
||||
}
|
||||
|
||||
// Return a |JNIEnv*| usable on this thread or NULL if this thread is detached.
|
||||
JNIEnv* GetEnv() {
|
||||
void* env = nullptr;
|
||||
jint status = g_jvm->GetEnv(&env, JNI_VERSION_1_6);
|
||||
RTC_CHECK(((env != nullptr) && (status == JNI_OK)) ||
|
||||
((env == nullptr) && (status == JNI_EDETACHED)))
|
||||
<< "Unexpected GetEnv return: " << status << ":" << env;
|
||||
return reinterpret_cast<JNIEnv*>(env);
|
||||
}
|
||||
|
||||
static void ThreadDestructor(void* prev_jni_ptr) {
|
||||
// This function only runs on threads where |g_jni_ptr| is non-NULL, meaning
|
||||
// we were responsible for originally attaching the thread, so are responsible
|
||||
// for detaching it now. However, because some JVM implementations (notably
|
||||
// Oracle's http://goo.gl/eHApYT) also use the pthread_key_create mechanism,
|
||||
// the JVMs accounting info for this thread may already be wiped out by the
|
||||
// time this is called. Thus it may appear we are already detached even though
|
||||
// it was our responsibility to detach! Oh well.
|
||||
if (!GetEnv())
|
||||
return;
|
||||
|
||||
RTC_CHECK(GetEnv() == prev_jni_ptr)
|
||||
<< "Detaching from another thread: " << prev_jni_ptr << ":" << GetEnv();
|
||||
jint status = g_jvm->DetachCurrentThread();
|
||||
RTC_CHECK(status == JNI_OK) << "Failed to detach thread: " << status;
|
||||
RTC_CHECK(!GetEnv()) << "Detaching was a successful no-op???";
|
||||
}
|
||||
|
||||
static void CreateJNIPtrKey() {
|
||||
RTC_CHECK(!pthread_key_create(&g_jni_ptr, &ThreadDestructor))
|
||||
<< "pthread_key_create";
|
||||
}
|
||||
|
||||
jint InitGlobalJniVariables(JavaVM *jvm) {
|
||||
RTC_CHECK(!g_jvm) << "InitGlobalJniVariables!";
|
||||
g_jvm = jvm;
|
||||
RTC_CHECK(g_jvm) << "InitGlobalJniVariables handed NULL?";
|
||||
|
||||
RTC_CHECK(!pthread_once(&g_jni_ptr_once, &CreateJNIPtrKey)) << "pthread_once";
|
||||
|
||||
JNIEnv* jni = nullptr;
|
||||
if (jvm->GetEnv(reinterpret_cast<void**>(&jni), JNI_VERSION_1_6) != JNI_OK)
|
||||
return -1;
|
||||
|
||||
return JNI_VERSION_1_6;
|
||||
}
|
||||
|
||||
// Return thread ID as a string.
|
||||
static std::string GetThreadId() {
|
||||
char buf[21]; // Big enough to hold a kuint64max plus terminating NULL.
|
||||
RTC_CHECK_LT(snprintf(buf, sizeof(buf), "%ld",
|
||||
static_cast<long>(syscall(__NR_gettid))),
|
||||
sizeof(buf))
|
||||
<< "Thread id is bigger than uint64??";
|
||||
return std::string(buf);
|
||||
}
|
||||
|
||||
// Return the current thread's name.
|
||||
static std::string GetThreadName() {
|
||||
char name[17] = {0};
|
||||
if (prctl(PR_GET_NAME, name) != 0)
|
||||
return std::string("<noname>");
|
||||
return std::string(name);
|
||||
}
|
||||
|
||||
// Return a |JNIEnv*| usable on this thread. Attaches to |g_jvm| if necessary.
|
||||
JNIEnv* AttachCurrentThreadIfNeeded() {
|
||||
JNIEnv* jni = GetEnv();
|
||||
if (jni)
|
||||
return jni;
|
||||
RTC_CHECK(!pthread_getspecific(g_jni_ptr))
|
||||
<< "TLS has a JNIEnv* but not attached?";
|
||||
|
||||
std::string name(GetThreadName() + " - " + GetThreadId());
|
||||
JavaVMAttachArgs args;
|
||||
args.version = JNI_VERSION_1_6;
|
||||
args.name = &name[0];
|
||||
args.group = nullptr;
|
||||
// Deal with difference in signatures between Oracle's jni.h and Android's.
|
||||
#ifdef _JAVASOFT_JNI_H_ // Oracle's jni.h violates the JNI spec!
|
||||
void* env = nullptr;
|
||||
#else
|
||||
JNIEnv* env = nullptr;
|
||||
#endif
|
||||
RTC_CHECK(!g_jvm->AttachCurrentThread(&env, &args))
|
||||
<< "Failed to attach thread";
|
||||
RTC_CHECK(env) << "AttachCurrentThread handed back NULL!";
|
||||
jni = reinterpret_cast<JNIEnv*>(env);
|
||||
RTC_CHECK(!pthread_setspecific(g_jni_ptr, jni)) << "pthread_setspecific";
|
||||
return jni;
|
||||
}
|
||||
|
||||
// Return a |jlong| that will correctly convert back to |ptr|. This is needed
|
||||
// because the alternative (of silently passing a 32-bit pointer to a vararg
|
||||
// function expecting a 64-bit param) picks up garbage in the high 32 bits.
|
||||
jlong jlongFromPointer(void* ptr) {
|
||||
static_assert(sizeof(intptr_t) <= sizeof(jlong),
|
||||
"Time to rethink the use of jlongs");
|
||||
// Going through intptr_t to be obvious about the definedness of the
|
||||
// conversion from pointer to integral type. intptr_t to jlong is a standard
|
||||
// widening by the static_assert above.
|
||||
jlong ret = reinterpret_cast<intptr_t>(ptr);
|
||||
RTC_DCHECK(reinterpret_cast<void*>(ret) == ptr);
|
||||
return ret;
|
||||
}
|
||||
|
||||
// JNIEnv-helper methods that RTC_CHECK success: no Java exception thrown and
|
||||
// found object/class/method/field is non-null.
|
||||
jmethodID GetMethodID(
|
||||
JNIEnv* jni, jclass c, const std::string& name, const char* signature) {
|
||||
jmethodID m = jni->GetMethodID(c, name.c_str(), signature);
|
||||
CHECK_EXCEPTION(jni) << "error during GetMethodID: " << name << ", "
|
||||
<< signature;
|
||||
RTC_CHECK(m) << name << ", " << signature;
|
||||
return m;
|
||||
}
|
||||
|
||||
jmethodID GetStaticMethodID(
|
||||
JNIEnv* jni, jclass c, const char* name, const char* signature) {
|
||||
jmethodID m = jni->GetStaticMethodID(c, name, signature);
|
||||
CHECK_EXCEPTION(jni) << "error during GetStaticMethodID: " << name << ", "
|
||||
<< signature;
|
||||
RTC_CHECK(m) << name << ", " << signature;
|
||||
return m;
|
||||
}
|
||||
|
||||
jfieldID GetFieldID(
|
||||
JNIEnv* jni, jclass c, const char* name, const char* signature) {
|
||||
jfieldID f = jni->GetFieldID(c, name, signature);
|
||||
CHECK_EXCEPTION(jni) << "error during GetFieldID";
|
||||
RTC_CHECK(f) << name << ", " << signature;
|
||||
return f;
|
||||
}
|
||||
|
||||
jclass GetObjectClass(JNIEnv* jni, jobject object) {
|
||||
jclass c = jni->GetObjectClass(object);
|
||||
CHECK_EXCEPTION(jni) << "error during GetObjectClass";
|
||||
RTC_CHECK(c) << "GetObjectClass returned NULL";
|
||||
return c;
|
||||
}
|
||||
|
||||
jobject GetObjectField(JNIEnv* jni, jobject object, jfieldID id) {
|
||||
jobject o = jni->GetObjectField(object, id);
|
||||
CHECK_EXCEPTION(jni) << "error during GetObjectField";
|
||||
RTC_CHECK(!IsNull(jni, o)) << "GetObjectField returned NULL";
|
||||
return o;
|
||||
}
|
||||
|
||||
jobject GetNullableObjectField(JNIEnv* jni, jobject object, jfieldID id) {
|
||||
jobject o = jni->GetObjectField(object, id);
|
||||
CHECK_EXCEPTION(jni) << "error during GetObjectField";
|
||||
return o;
|
||||
}
|
||||
|
||||
jstring GetStringField(JNIEnv* jni, jobject object, jfieldID id) {
|
||||
return static_cast<jstring>(GetObjectField(jni, object, id));
|
||||
}
|
||||
|
||||
jlong GetLongField(JNIEnv* jni, jobject object, jfieldID id) {
|
||||
jlong l = jni->GetLongField(object, id);
|
||||
CHECK_EXCEPTION(jni) << "error during GetLongField";
|
||||
return l;
|
||||
}
|
||||
|
||||
jint GetIntField(JNIEnv* jni, jobject object, jfieldID id) {
|
||||
jint i = jni->GetIntField(object, id);
|
||||
CHECK_EXCEPTION(jni) << "error during GetIntField";
|
||||
return i;
|
||||
}
|
||||
|
||||
bool GetBooleanField(JNIEnv* jni, jobject object, jfieldID id) {
|
||||
jboolean b = jni->GetBooleanField(object, id);
|
||||
CHECK_EXCEPTION(jni) << "error during GetBooleanField";
|
||||
return b;
|
||||
}
|
||||
|
||||
bool IsNull(JNIEnv* jni, jobject obj) {
|
||||
return jni->IsSameObject(obj, nullptr);
|
||||
}
|
||||
|
||||
// Given a UTF-8 encoded |native| string return a new (UTF-16) jstring.
|
||||
jstring JavaStringFromStdString(JNIEnv* jni, const std::string& native) {
|
||||
jstring jstr = jni->NewStringUTF(native.c_str());
|
||||
CHECK_EXCEPTION(jni) << "error during NewStringUTF";
|
||||
return jstr;
|
||||
}
|
||||
|
||||
// Given a (UTF-16) jstring return a new UTF-8 native string.
|
||||
std::string JavaToStdString(JNIEnv* jni, const jstring& j_string) {
|
||||
const char* chars = jni->GetStringUTFChars(j_string, nullptr);
|
||||
CHECK_EXCEPTION(jni) << "Error during GetStringUTFChars";
|
||||
std::string str(chars, jni->GetStringUTFLength(j_string));
|
||||
CHECK_EXCEPTION(jni) << "Error during GetStringUTFLength";
|
||||
jni->ReleaseStringUTFChars(j_string, chars);
|
||||
CHECK_EXCEPTION(jni) << "Error during ReleaseStringUTFChars";
|
||||
return str;
|
||||
}
|
||||
|
||||
// Return the (singleton) Java Enum object corresponding to |index|;
|
||||
jobject JavaEnumFromIndex(JNIEnv* jni, jclass state_class,
|
||||
const std::string& state_class_name, int index) {
|
||||
jmethodID state_values_id = GetStaticMethodID(
|
||||
jni, state_class, "values", ("()[L" + state_class_name + ";").c_str());
|
||||
jobjectArray state_values = static_cast<jobjectArray>(
|
||||
jni->CallStaticObjectMethod(state_class, state_values_id));
|
||||
CHECK_EXCEPTION(jni) << "error during CallStaticObjectMethod";
|
||||
jobject ret = jni->GetObjectArrayElement(state_values, index);
|
||||
CHECK_EXCEPTION(jni) << "error during GetObjectArrayElement";
|
||||
return ret;
|
||||
}
|
||||
|
||||
std::string GetJavaEnumName(JNIEnv* jni,
|
||||
const std::string& className,
|
||||
jobject j_enum) {
|
||||
jclass enumClass = FindClass(jni, className.c_str());
|
||||
jmethodID nameMethod =
|
||||
GetMethodID(jni, enumClass, "name", "()Ljava/lang/String;");
|
||||
jstring name =
|
||||
reinterpret_cast<jstring>(jni->CallObjectMethod(j_enum, nameMethod));
|
||||
CHECK_EXCEPTION(jni) << "error during CallObjectMethod for " << className
|
||||
<< ".name";
|
||||
return JavaToStdString(jni, name);
|
||||
}
|
||||
|
||||
jobject NewGlobalRef(JNIEnv* jni, jobject o) {
|
||||
jobject ret = jni->NewGlobalRef(o);
|
||||
CHECK_EXCEPTION(jni) << "error during NewGlobalRef";
|
||||
RTC_CHECK(ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void DeleteGlobalRef(JNIEnv* jni, jobject o) {
|
||||
jni->DeleteGlobalRef(o);
|
||||
CHECK_EXCEPTION(jni) << "error during DeleteGlobalRef";
|
||||
}
|
||||
|
||||
// Scope Java local references to the lifetime of this object. Use in all C++
|
||||
// callbacks (i.e. entry points that don't originate in a Java callstack
|
||||
// through a "native" method call).
|
||||
ScopedLocalRefFrame::ScopedLocalRefFrame(JNIEnv* jni) : jni_(jni) {
|
||||
RTC_CHECK(!jni_->PushLocalFrame(0)) << "Failed to PushLocalFrame";
|
||||
}
|
||||
ScopedLocalRefFrame::~ScopedLocalRefFrame() {
|
||||
jni_->PopLocalFrame(nullptr);
|
||||
}
|
||||
|
||||
// Creates an iterator representing the end of any collection.
|
||||
Iterable::Iterator::Iterator() : iterator_(nullptr) {}
|
||||
|
||||
// Creates an iterator pointing to the beginning of the specified collection.
|
||||
Iterable::Iterator::Iterator(JNIEnv* jni, jobject iterable) : jni_(jni) {
|
||||
jclass j_class = GetObjectClass(jni, iterable);
|
||||
jmethodID iterator_id =
|
||||
GetMethodID(jni, j_class, "iterator", "()Ljava/util/Iterator;");
|
||||
iterator_ = jni->CallObjectMethod(iterable, iterator_id);
|
||||
CHECK_EXCEPTION(jni) << "error during CallObjectMethod";
|
||||
RTC_CHECK(iterator_ != nullptr);
|
||||
|
||||
jclass iterator_class = GetObjectClass(jni, iterator_);
|
||||
has_next_id_ = GetMethodID(jni, iterator_class, "hasNext", "()Z");
|
||||
next_id_ = GetMethodID(jni, iterator_class, "next", "()Ljava/lang/Object;");
|
||||
|
||||
// Start at the first element in the collection.
|
||||
++(*this);
|
||||
}
|
||||
|
||||
// Move constructor - necessary to be able to return iterator types from
|
||||
// functions.
|
||||
Iterable::Iterator::Iterator(Iterator&& other)
|
||||
: jni_(std::move(other.jni_)),
|
||||
iterator_(std::move(other.iterator_)),
|
||||
value_(std::move(other.value_)),
|
||||
has_next_id_(std::move(other.has_next_id_)),
|
||||
next_id_(std::move(other.next_id_)),
|
||||
thread_checker_(std::move(other.thread_checker_)){};
|
||||
|
||||
// Advances the iterator one step.
|
||||
Iterable::Iterator& Iterable::Iterator::operator++() {
|
||||
RTC_CHECK(thread_checker_.CalledOnValidThread());
|
||||
if (AtEnd()) {
|
||||
// Can't move past the end.
|
||||
return *this;
|
||||
}
|
||||
bool has_next = jni_->CallBooleanMethod(iterator_, has_next_id_);
|
||||
CHECK_EXCEPTION(jni_) << "error during CallBooleanMethod";
|
||||
if (!has_next) {
|
||||
iterator_ = nullptr;
|
||||
value_ = nullptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
value_ = jni_->CallObjectMethod(iterator_, next_id_);
|
||||
CHECK_EXCEPTION(jni_) << "error during CallObjectMethod";
|
||||
return *this;
|
||||
}
|
||||
|
||||
// Provides a way to compare the iterator with itself and with the end iterator.
|
||||
// Note: all other comparison results are undefined, just like for C++ input
|
||||
// iterators.
|
||||
bool Iterable::Iterator::operator==(const Iterable::Iterator& other) {
|
||||
// Two different active iterators should never be compared.
|
||||
RTC_DCHECK(this == &other || AtEnd() || other.AtEnd());
|
||||
return AtEnd() == other.AtEnd();
|
||||
}
|
||||
|
||||
jobject Iterable::Iterator::operator*() {
|
||||
RTC_CHECK(!AtEnd());
|
||||
return value_;
|
||||
}
|
||||
|
||||
bool Iterable::Iterator::AtEnd() const {
|
||||
RTC_CHECK(thread_checker_.CalledOnValidThread());
|
||||
return jni_ == nullptr || IsNull(jni_, iterator_);
|
||||
}
|
||||
|
||||
} // namespace webrtc_jni
|
||||
Reference in New Issue
Block a user