void DuktapeContext::set(JNIEnv *env, jstring name, jobject object, jobjectArray methods) {
CHECK_STACK(m_context);
duk_push_global_object(m_context);
const JString instanceName(env, name);
if (duk_has_prop_string(m_context, -1, instanceName)) {
duk_pop(m_context);
queueIllegalArgumentException(env,
"A global object called " + instanceName.str() + " already exists");
return;
}
const duk_idx_t objIndex = duk_require_normalize_index(m_context, duk_push_object(m_context));
// Hook up a finalizer to decrement the refcount and clean up our JavaMethods.
duk_push_c_function(m_context, javaObjectFinalizer, 1);
duk_set_finalizer(m_context, objIndex);
const jsize numMethods = env->GetArrayLength(methods);
for (jsize i = 0; i < numMethods; ++i) {
jobject method = env->GetObjectArrayElement(methods, i);
const jmethodID getName =
env->GetMethodID(env->GetObjectClass(method), "getName", "()Ljava/lang/String;");
const JString methodName(env, static_cast<jstring>(env->CallObjectMethod(method, getName)));
std::unique_ptr<JavaMethod> javaMethod;
try {
javaMethod.reset(new JavaMethod(m_javaValues, env, method));
} catch (const std::invalid_argument& e) {
queueIllegalArgumentException(env, "In bound method \"" +
instanceName.str() + "." + methodName.str() + "\": " + e.what());
// Pop the object being bound and the duktape global object.
duk_pop_2(m_context);
return;
}
// Use VARARGS here to allow us to manually validate that the proper number of arguments are
// given in the call. If we specify the actual number of arguments needed, Duktape will try to
// be helpful by discarding extra or providing missing arguments. That's not quite what we want.
// See http://duktape.org/api.html#duk_push_c_function for details.
const duk_idx_t func = duk_push_c_function(m_context, javaMethodHandler, DUK_VARARGS);
duk_push_pointer(m_context, javaMethod.release());
duk_put_prop_string(m_context, func, JAVA_METHOD_PROP_NAME);
// Add this method to the bound object.
duk_put_prop_string(m_context, objIndex, methodName);
}
// Keep a reference in JavaScript to the object being bound.
duk_push_pointer(m_context, env->NewGlobalRef(object));
duk_put_prop_string(m_context, objIndex, JAVA_THIS_PROP_NAME);
// Make our bound Java object a property of the Duktape global object (so it's a JS global).
duk_put_prop_string(m_context, -2, instanceName);
// Pop the Duktape global object off the stack.
duk_pop(m_context);
}
void JExtractorPlugin::finishedExtraction(JNIEnv* env, jobject jthis, jobjectArray jlinks)
{
JExtractorPlugin* This = static_cast<JExtractorPlugin*>(getCObject(jthis));
JArray links(jlinks);
QList<QString> list;
qDebug() << list;
for (size_t i = 0; i < links.size(); i++)
{
JString str = links.getObject(i).toStringShallow();
list << str.str();
}
static_cast<JavaExtractor*>(This->m_transfer)->finishedExtraction(list);
This->m_bTaskDone = true;
}
jobject JavaScriptObject::call(JNIEnv* env, jobject method, jobjectArray args) const {
CHECK_STACK(m_context);
if (m_instance == nullptr) {
queueDuktapeException(env, "JavaScript object " + m_name + " has been garbage collected");
return nullptr;
}
const auto methodIter = m_methods.find(env->FromReflectedMethod(method));
if (methodIter != m_methods.end()) {
return methodIter->second(env, m_context, m_instance, args);
}
// Failed to find the method in our map - should be impossible!
const jclass methodClass = env->GetObjectClass(method);
const jmethodID getName = env->GetMethodID(methodClass, "getName", "()Ljava/lang/String;");
const JString methodName(env, static_cast<jstring>(env->CallObjectMethod(method, getName)));
queueDuktapeException(env, "Could not find method " + m_name + "." + methodName.str());
return nullptr;
}
JavaScriptObject::JavaScriptObject(JavaTypeMap& typeMap, JNIEnv* env, duk_context* context,
jstring name, jobjectArray methods)
: m_name(JString(env, name).str())
, m_context(context)
, m_instance(nullptr)
, m_nextFinalizer(nullptr) {
CHECK_STACK(m_context);
duk_push_global_object(m_context);
if (!duk_get_prop_string(m_context, -1, m_name.c_str())) {
duk_pop_2(m_context);
throw std::invalid_argument("A global JavaScript object called " + m_name + " was not found");
}
m_instance = duk_get_heapptr(m_context, -1);
if (m_instance == nullptr) {
duk_pop_2(m_context);
throw std::invalid_argument("JavaScript global called " + m_name + " is not an object");
}
// Make sure that the object has all of the methods we want.
jmethodID getName = nullptr;
const jsize numArgs = env->GetArrayLength(methods);
for (jsize i = 0; i < numArgs; ++i) {
auto method = env->GetObjectArrayElement(methods, i);
if (getName == nullptr) {
jclass methodClass = env->GetObjectClass(method);
getName = env->GetMethodID(methodClass, "getName", "()Ljava/lang/String;");
}
// Sanity check that as of right now, the object we're proxying has a function with this name.
const JString methodName(env, static_cast<jstring>(env->CallObjectMethod(method, getName)));
if (!duk_get_prop_string(m_context, -1, methodName)) {
duk_pop_3(m_context);
throw std::runtime_error("JavaScript global " + m_name + " has no method called " +
methodName.str());
} else if (!duk_is_callable(m_context, -1)) {
duk_pop_3(m_context);
throw std::runtime_error("JavaScript property " + m_name + "." + methodName.str() +
" not callable");
}
try {
// Build a call wrapper that handles marshalling the arguments and return value.
m_methods.emplace(std::make_pair(env->FromReflectedMethod(method),
buildMethodBody(typeMap, env, method, methodName.str())));
} catch (const std::invalid_argument& e) {
duk_pop_3(m_context);
throw std::invalid_argument("In proxied method \"" + m_name + "." + methodName.str() +
"\": " + e.what());
}
// Pop the method property.
duk_pop(m_context);
}
// Keep track of any previously registered finalizer.
duk_get_finalizer(m_context, -1);
m_nextFinalizer = duk_is_c_function(m_context, -1)
? duk_get_c_function(m_context, -1)
: nullptr;
duk_pop(m_context);
duk_push_c_function(m_context, JavaScriptObject::finalizer, 1);
duk_set_finalizer(m_context, -2);
// Add 'this' to the list of pointers attached to the proxied instance.
// TODO: don't use an array here, just use a separate hidden property for each proxy.
if (!duk_has_prop_string(m_context, -1, WRAPPER_THIS_PROP_NAME)) {
duk_push_array(m_context);
} else {
duk_get_prop_string(m_context, -1, WRAPPER_THIS_PROP_NAME);
}
const duk_size_t length = duk_get_length(m_context, -1);
duk_push_pointer(m_context, this);
duk_put_prop_index(m_context, -2, static_cast<duk_uarridx_t>(length));
// Add the array (back) to the instance.
duk_put_prop_string(m_context, -2, WRAPPER_THIS_PROP_NAME);
// Pop the global and our instance.
duk_pop_2(m_context);
}