bool Type::is_object() const {
Class* cls = clazz();
return is_object_proto() || is_functor()
|| (cls && cls->proto()->is_object_proto())
|| (cls && !cls->proto()->is_proto());
// Note: If the user specified an invalid proto, then error out
}
void throw_exception(JNIEnv *env, char const *name, char const *message)
{
safe_jni::safe_local_ref<jclass> clazz(getEnv(), getEnv()->FindClass(name));
if (!clazz) {
return;
}
getEnv()->ThrowNew(clazz.get(), message);
}
// static
jobject JHwParcel::NewObject(JNIEnv *env) {
ScopedLocalRef<jclass> clazz(env, FindClassOrDie(env, CLASS_PATH));
jmethodID constructID =
GetMethodIDOrDie(env, clazz.get(), "<init>", "(Z)V");
return env->NewObject(clazz.get(), constructID, false /* allocate */);
}
SEXP class__newInstance(SEXP args) {
SEXP p = CDR(args);
XP_Module module(CAR(p)); p = CDR(p);
XP_Class clazz(CAR(p)); p = CDR(p);
UNPACK_EXTERNAL_ARGS(cargs,p)
return clazz->newInstance(cargs, nargs);
}
static jobject makeLongObject(JNIEnv *env, int64_t value) {
ScopedLocalRef<jclass> clazz(env, env->FindClass("java/lang/Long"));
CHECK(clazz.get() != NULL);
jmethodID longConstructID = env->GetMethodID(clazz.get(), "<init>", "(J)V");
CHECK(longConstructID != NULL);
return env->NewObject(clazz.get(), longConstructID, value);
}
// static
void JHwParcel::InitClass(JNIEnv *env) {
ScopedLocalRef<jclass> clazz(
env, FindClassOrDie(env, CLASS_PATH));
gFields.contextID =
GetFieldIDOrDie(env, clazz.get(), "mNativeContext", "J");
gFields.constructID = GetMethodIDOrDie(env, clazz.get(), "<init>", "(Z)V");
}
static jobject makeFloatObject(JNIEnv *env, float value) {
ScopedLocalRef<jclass> clazz(env, env->FindClass("java/lang/Float"));
CHECK(clazz.get() != NULL);
jmethodID floatConstructID =
env->GetMethodID(clazz.get(), "<init>", "(F)V");
CHECK(floatConstructID != NULL);
return env->NewObject(clazz.get(), floatConstructID, value);
}
static jobject makeIntegerObject(JNIEnv *env, int32_t value) {
ScopedLocalRef<jclass> clazz(env, env->FindClass("java/lang/Integer"));
CHECK(clazz.get() != NULL);
jmethodID integerConstructID =
env->GetMethodID(clazz.get(), "<init>", "(I)V");
CHECK(integerConstructID != NULL);
return env->NewObject(clazz.get(), integerConstructID, value);
}
LocalRef<jobject> newPrimitiveWrapper(const T obj) {
using jinfo = traits::jinfo<T>;
static_assert(jinfo::is_primitive, "Should be primitive.");
const Context::Handle ctx = Context::getContext();
LocalRef<jclass> clazz(ctx->env()->FindClass(jinfo::jwrapperclass().c_str()));
const jmethodID valueOfId = ctx->env()->GetStaticMethodID(
clazz.get(), "valueOf", jinfo::valueOfSig().c_str());
LocalRef<jobject> wrapper(
ctx->env()->CallStaticObjectMethod(clazz.get(), valueOfId, obj));
ctx->throwIfOccured();
return wrapper;
}
void getIterable(jobject jobj, const std::function<void(jobject)> &cb) {
const Context::Handle ctx = Context::getContext();
LocalRef<jclass> clazz(ctx->env()->GetObjectClass(jobj));
const jmethodID iteratorId = ctx->env()->GetMethodID(
clazz.get(), "iterator", "()Ljava/util/Iterator;");
LocalRef<jobject> iter(ctx->env()->CallObjectMethod(jobj, iteratorId));
LocalRef<jclass> iterClass(ctx->env()->GetObjectClass(iter.get()));
const jmethodID hasNextId =
ctx->env()->GetMethodID(iterClass.get(), "hasNext", "()Z");
const jmethodID nextId =
ctx->env()->GetMethodID(iterClass.get(), "next", "()Ljava/lang/Object;");
while (ctx->env()->CallBooleanMethod(iter.get(), hasNextId)) {
LocalRef<jobject> jobj(ctx->env()->CallObjectMethod(iter.get(), nextId));
ctx->throwIfOccured();
cb(jobj.get());
}
}
static jobject NewJniObject(JNIEnv* env, const T& value, const char* javaClass)
{
if (!value.get())
{
return 0;
}
JniLocalReference<jclass> clazz(
env,
env->FindClass(javaClass));
jmethodID method = env->GetMethodID(*clazz, "<init>", "(J)V");
return env->NewObject(
*clazz,
method,
JniPtrToLong(new T(value)));
}
std::string AndroidGetPackageName()
{
JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv();
jobject activity = (jobject)SDL_AndroidGetActivity();
jclass clazz(env->GetObjectClass(activity));
jmethodID method_id = env->GetMethodID(clazz, "getPackageName", "()Ljava/lang/String;");
jstring packageName = (jstring)env->CallObjectMethod(activity, method_id);
const char* name = env->GetStringUTFChars(packageName, NULL);
std::string result(name);
env->ReleaseStringUTFChars(packageName, name);
env->DeleteLocalRef(activity);
env->DeleteLocalRef(clazz);
return result;
}
SEXP CppMethod__invoke_notvoid(SEXP args) {
SEXP p = CDR(args);
// the external pointer to the class
XP_Class clazz(CAR(p)); p = CDR(p);
// the external pointer to the method
SEXP met = CAR(p); p = CDR(p);
// the external pointer to the object
SEXP obj = CAR(p); p = CDR(p);
CHECK_DUMMY_OBJ(obj);
// additional arguments, processed the same way as .Call does
UNPACK_EXTERNAL_ARGS(cargs,p)
return clazz->invoke_notvoid(met, obj, cargs, nargs);
}
void getMap(jobject jobj, const std::function<void(jobject, jobject)> &cb) {
const Context::Handle ctx = Context::getContext();
LocalRef<jclass> clazz(ctx->env()->GetObjectClass(jobj));
const jmethodID entrySetId =
ctx->env()->GetMethodID(clazz.get(), "entrySet", "()Ljava/util/Set;");
LocalRef<jobject> entrySet(ctx->env()->CallObjectMethod(jobj, entrySetId));
LocalRef<jclass> mapEntryClass(ctx->env()->FindClass("java/util/Map$Entry"));
const jmethodID getKeyId = ctx->env()->GetMethodID(
mapEntryClass.get(), "getKey", "()Ljava/lang/Object;");
const jmethodID getValueId = ctx->env()->GetMethodID(
mapEntryClass.get(), "getValue", "()Ljava/lang/Object;");
ctx->throwIfOccured();
getIterable(entrySet.get(), [&ctx, &cb, getKeyId, getValueId](jobject jobj) {
LocalRef<jobject> jkey(ctx->env()->CallObjectMethod(jobj, getKeyId));
LocalRef<jobject> jvalue(ctx->env()->CallObjectMethod(jobj, getValueId));
cb(jkey.get(), jvalue.get());
});
}
status_t JMediaCodec::dequeueOutputBuffer(
JNIEnv *env, jobject bufferInfo, size_t *index, int64_t timeoutUs) {
size_t size, offset;
int64_t timeUs;
uint32_t flags;
status_t err;
if ((err = mCodec->dequeueOutputBuffer(
index, &offset, &size, &timeUs, &flags, timeoutUs)) != OK) {
return err;
}
ScopedLocalRef<jclass> clazz(
env, env->FindClass("android/media/MediaCodec$BufferInfo"));
jmethodID method = env->GetMethodID(clazz.get(), "set", "(IIJI)V");
env->CallVoidMethod(bufferInfo, method, offset, size, timeUs, flags);
return OK;
}
void ExceptionTranslator::Translate(CJavascriptException const& ex)
{
CPythonGIL python_gil;
if (ex.m_type)
{
::PyErr_SetString(ex.m_type, ex.what());
}
else
{
v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
if (!ex.Exception().IsEmpty() && ex.Exception()->IsObject())
{
v8::Handle<v8::Object> obj = ex.Exception()->ToObject();
v8::Handle<v8::Value> exc_type = obj->GetHiddenValue(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), "exc_type"));
v8::Handle<v8::Value> exc_value = obj->GetHiddenValue(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), "exc_value"));
if (!exc_type.IsEmpty() && !exc_value.IsEmpty())
{
std::auto_ptr<py::object> type(static_cast<py::object *>(v8::Handle<v8::External>::Cast(exc_type)->Value())),
value(static_cast<py::object *>(v8::Handle<v8::External>::Cast(exc_value)->Value()));
::PyErr_SetObject(type->ptr(), value->ptr());
return;
}
}
// Boost::Python doesn't support inherite from Python class,
// so, just use some workaround to throw our custom exception
//
// http://www.language-binding.net/pyplusplus/troubleshooting_guide/exceptions/exceptions.html
py::object impl(ex);
py::object clazz = impl.attr("_jsclass");
py::object err = clazz(impl);
::PyErr_SetObject(clazz.ptr(), py::incref(err.ptr()));
}
}
static jobject makeByteBufferObject(
JNIEnv *env, const void *data, size_t size) {
jbyteArray byteArrayObj = env->NewByteArray(size);
env->SetByteArrayRegion(byteArrayObj, 0, size, (const jbyte *)data);
ScopedLocalRef<jclass> clazz(env, env->FindClass("java/nio/ByteBuffer"));
CHECK(clazz.get() != NULL);
jmethodID byteBufWrapID =
env->GetStaticMethodID(
clazz.get(), "wrap", "([B)Ljava/nio/ByteBuffer;");
CHECK(byteBufWrapID != NULL);
jobject byteBufObj = env->CallStaticObjectMethod(
clazz.get(), byteBufWrapID, byteArrayObj);
env->DeleteLocalRef(byteArrayObj); byteArrayObj = NULL;
return byteBufObj;
}
bool Type::equals(Type const* other) const {
// Make sure the classes are equal
if (clazz() != other->clazz()) {
return false;
}
if (other->name() != name()) {
return false;
}
// Make sure the generic parameters are the same
Generic* g1 = generics();
Generic* g2 = other->generics();
while (g1 && g2) {
if (!g1->type()->equals(g2->type())) {
return false;
}
g1 = g1->next();
g2 = g2->next();
}
return true;
}
bool Type::is_interface() const {
Class* cls = clazz();
return is_interface_proto() || (cls && cls->proto()->is_interface_proto());
}
bool Type::is_value() const {
Class* cls = clazz();
return is_primitive() || is_value_proto()
|| (cls && cls->proto()->is_value_proto());
}
bool Type::is_union() const {
Class* cls = clazz();
return is_union_proto() || (cls && cls->proto()->is_union_proto());
}
/**
* The unsigned indexbyte1 and indexbyte2 are used to construct an index into the runtime constant pool of the current class (§2.6),
* where the value of the index is (indexbyte1 << 8) | indexbyte2. The runtime constant pool item at that index must be a symbolic reference to a method (§5.1),
* which gives the name and descriptor (§4.3.3) of the method as well as a symbolic reference to the class in which the method is to be found.
* The named method is resolved (§5.4.3.3). Finally, if the resolved method is protected (§4.6), and it is a member of a superclass of the current class,
* and the method is not declared in the same runtime package (§5.3) as the current class,
* then the class of objectref must be either the current class or a subclass of the current class.
*/
void JavaVM::pushNewFrame(StackFrame * stackFrame)
{
Frame * frame = stackFrame->top();
//get a process counter and get a next instruction
//invoke instance method on object objectref, where the method is identified by method reference index in constant pool (indexbyte1 << 8 + indexbyte2)
u1 * ptr = &frame->_code->code[frame->_pc + 1];
u2 method_index = getu2(ptr);
CPBase * pConstPool = frame->_clazz->_constantPool[method_index];
//get method
ASSERT(pConstPool->tag == CONSTANT_Methodref);
CONSTANT_Methodref_info_resolve * method_ref = reinterpret_cast<CONSTANT_Methodref_info_resolve *>(pConstPool);
/*get class name*/
std::string class_name;
class_name.assign((const char *)method_ref->_class_index->_name_index->bytes, method_ref->_class_index->_name_index->length);
boost::shared_ptr<JavaClass> clazz(_classHeap->getClass(class_name));
/*get method*/
std::string method_name, method_desc;
frame->_clazz->getStringFromConstPool(method_ref->_name_and_type_index->name_index, method_name);
frame->_clazz->getStringFromConstPool(method_ref->_name_and_type_index->descriptor_index, method_desc);
printf("invoke %s.%s:%s\n", class_name.c_str(), method_name.c_str(), method_desc.c_str());
jClass virtual_clazz(clazz);
u2 nIndex = clazz->getMethodID(method_name, method_desc, virtual_clazz);
Frame * new_f = new Frame();
new_f->_clazz = virtual_clazz;
new_f->_method = virtual_clazz->_methods[nIndex];
if (!(virtual_clazz->_methods[nIndex]->getAccessFlags() & ACC_NATIVE)) // there is no code
{
Code_attribute * code = virtual_clazz->getMethodCodeAttribute(nIndex);
new_f->setCode(code);
}
else
{
Code_attribute * code = new Code_attribute();
code->max_locals = 1;
code->max_stack = 0;
code->code = NULL;
new_f->setCode(code);
}
/*
* The Java virtual machine uses local variables to pass parameters on method invocation
* http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-2.html#jvms-2.6.1
*/
std::string params = countMethodStack(method_desc);
for (std::size_t i = params.length(), j = i; i >= 0; i--, j--)
{
/**
* The objectref and the argument values are consecutively made the values of local variables of the new frame,
* with objectref in local variable 0,
* arg1 in local variable 1 (or, if arg1 is of type long or double, in local variables 1 and 2), and so on
*/
new_f->_localVariable[i] = frame->_operandStack.top();
frame->_operandStack.pop();
//TODO melhorar
if (i == 0)
break;
/* if it is long or double I need to add 1 in local variable */
if(params.size() > 0 && (params[j-1] =='J' || params[j-1] =='D'))
i--;
}
if (new_f->_method->getAccessFlags() & ACC_SYNCHRONIZED)
{
if (lockMonitor(new_f->_localVariable[0]._var._objectref))
{
}
else
{
new_f->_lock = true;
new_f->_waitingObj = new_f->_localVariable[0]._var._objectref;
this->wait(new_f->_waitingObj, boost::bind(&Frame::unlock, new_f));
}
}
//if this method has ACC_SYNCHRONIZED then I need to do monitorenter, it is implicit
//I need to get new_f->_localVariable[0], this location in array is objref, I need to lock this object
stackFrame->push(new_f);
}
jobject NewJniArrayList(JNIEnv* env)
{
JniLocalReference<jclass> clazz(env, env->FindClass("java/util/ArrayList"));
jmethodID ctor = env->GetMethodID(*clazz, "<init>", "()V");
return env->NewObject(*clazz, ctor);
}
bool Type::is_functor() const {
Class* cls = clazz();
return is_functor_proto() || (cls && cls->proto()->is_functor_proto());
}
void JniThrowException(JNIEnv* env, const std::string& message)
{
JniLocalReference<jclass> clazz(env,
env->FindClass(PKG("AdblockPlusException")));
env->ThrowNew(*clazz, message.c_str());
}
void JniAddObjectToList(JNIEnv* env, jobject list, jobject value)
{
JniLocalReference<jclass> clazz(env, env->GetObjectClass(list));
jmethodID add = env->GetMethodID(*clazz, "add", "(Ljava/lang/Object;)Z");
env->CallBooleanMethod(list, add, value);
}
