void CVar_javaRegister()
{
class_CVar = (*javaEnv)->FindClass(javaEnv, "xreal/CVar");
if(CheckException() || !class_CVar)
{
Com_Error(ERR_FATAL, "Couldn't find xreal.CVar");
}
(*javaEnv)->RegisterNatives(javaEnv, class_CVar, CVar_methods, sizeof(CVar_methods) / sizeof(CVar_methods[0]));
if(CheckException())
{
Com_Error(ERR_FATAL, "Couldn't register native methods for xreal.CVar");
}
}
void Engine_javaRegister()
{
class_Engine = (*javaEnv)->FindClass(javaEnv, "xreal/Engine");
if(CheckException() || !class_Engine)
{
Com_Error(ERR_FATAL, "Couldn't find xreal.Engine");
}
(*javaEnv)->RegisterNatives(javaEnv, class_Engine, Engine_methods, sizeof(Engine_methods) / sizeof(Engine_methods[0]));
if(CheckException())
{
Com_Error(ERR_FATAL, "Couldn't register native methods for xreal.Engine");
}
}
jobject CreateJavaHaxeObjectRef (JNIEnv *env, value inValue) {
JNIInit (env);
if (!gJavaObjectsMutexInit) {
gJavaObjectsMutexInit = false;
pthread_mutex_init (&gJavaObjectsMutex, 0);
}
pthread_mutex_lock (&gJavaObjectsMutex);
JavaHaxeReferenceMap::iterator it = gJavaObjects.find (inValue);
if (it != gJavaObjects.end ()) {
it->second->refCount++;
} else {
gJavaObjects[inValue] = new JavaHaxeReference (inValue);
}
pthread_mutex_unlock (&gJavaObjectsMutex);
jobject result = env->CallStaticObjectMethod (HaxeObject, HaxeObject_create, (jlong)inValue);
jthrowable exc = env->ExceptionOccurred ();
CheckException (env);
return result;
}
bool FlingAnimator::update()
{
JNIEnv* env = m_javaScroller.env();
if (!env->CallBooleanMethod(m_javaScroller.obj(), m_computeMethodId)) {
CheckException(env);
stop();
return false;
}
WebCore::IntSize curr(env->CallIntMethod(m_javaScroller.obj(), m_getXMethodId),
env->CallIntMethod(m_javaScroller.obj(), m_getYMethodId));
CheckException(env);
m_scrollController->scrollBy(curr - m_last);
m_last = curr;
return true;
}
jobjectArray Java_NewConsoleArgs()
{
#if 1
int i, argc;
jobjectArray argsArray = NULL;
argc = Cmd_Argc();
if(argc <= 0)
return NULL;
argsArray = (*javaEnv)->NewObjectArray(javaEnv, argc, class_String, NULL);
for(i = 0; i < argc; i++) {
jstring argv = (*javaEnv)->NewStringUTF(javaEnv, Cmd_Argv(i));
(*javaEnv)->SetObjectArrayElement(javaEnv, argsArray, i, argv);
}
CheckException();
return argsArray;
#else
return NULL;
#endif
}
jclass FindClass(const char *className,bool inQuiet)
{
std::string cppClassName(className);
jclass ret;
if(jClassCache[cppClassName]!=NULL)
{
ret = jClassCache[cppClassName];
}
else
{
JNIEnv *env = GetEnv();
jclass tmp = env->FindClass(className);
if (!tmp)
{
if (inQuiet)
{
jthrowable exc = env->ExceptionOccurred();
if (exc)
env->ExceptionClear();
}
else
CheckException(env);
return 0;
}
ret = (jclass)env->NewGlobalRef(tmp);
jClassCache[cppClassName] = ret;
env->DeleteLocalRef(tmp);
}
return ret;
}
void UserCommand_javaRegister()
{
class_UserCommand = (*javaEnv)->FindClass(javaEnv, "xreal/UserCommand");
if(CheckException() || !class_UserCommand)
{
Com_Error(ERR_FATAL, "Couldn't find xreal.UserCommand");
}
//UserCommand(int serverTime, int pitch, int yaw, int roll, int buttons, byte weapon, byte forwardmove, byte rightmove, byte upmove)
method_UserCommand_ctor = (*javaEnv)->GetMethodID(javaEnv, class_UserCommand, "<init>", "(ISSSIBBBB)V");
}
void FlingAnimator::stop()
{
if (!m_scrollController.get())
return;
m_scrollController->scrollEnd();
m_scrollController->setUpdateCallback(0);
m_scrollController.clear();
m_last.setWidth(0);
m_last.setHeight(0);
JNIEnv* env = m_javaScroller.env();
env->CallVoidMethod(m_javaScroller.obj(), m_abortMethodId);
CheckException(env);
}
void FlingAnimator::triggerFling(PassRefPtr<ScrollController> controller, const WebGestureEvent& event)
{
ASSERT(event.type == WebInputEvent::GestureFlingStart);
if (!controller.get() || ((int)event.deltaX == 0 && (int)event.deltaY == 0))
return;
stop();
m_scrollController = controller;
const WebCore::IntRect& range = m_scrollController->scrollRange();
const WebCore::IntSize& over = m_scrollController->overScroll();
JNIEnv* env = m_javaScroller.env();
env->CallVoidMethod(m_javaScroller.obj(), m_flingMethodId, 0, 0, -(int)event.deltaX, -(int)event.deltaY,
range.x(), range.maxX(), range.y(), range.maxY(), over.width(), over.height());
CheckException(env);
m_scrollController->setUpdateCallback(FlingAnimator::fired);
}
void JVM_Shutdown(void)
{
Com_Printf("------- JVM_Shutdown() -------\n");
if(!javaEnv)
{
Com_Printf("Can't stop Java VM, javaEnv pointer was null\n");
return;
}
CheckException();
UserCommand_javaDetach();
CVar_javaDetach();
Engine_javaDetach();
Misc_javaDetach();
if(javaVMIsOurs)
{
JavaVM *jvm;
(*javaEnv)->GetJavaVM(javaEnv, &jvm);
if((*jvm)->DestroyJavaVM(jvm))
{
Com_Printf("Error destroying Java VM\n");
}
else
{
Com_Printf("Java VM Destroyed\n");
}
#if defined(USE_JAVA_DLOPEN)
JVM_JNI_Shutdown();
#endif
}
else
{
if((*javaVM)->DetachCurrentThread(javaVM))
{
Com_Printf("Couldn't detach from existing VM\n");
}
}
}
void DebugObject (JNIEnv *inEnv, const char *inMessage, jobject inObject) {
if (inObject == 0) {
ELOG ("%s : null", inMessage);
} else {
jclass cls = inEnv->GetObjectClass (inObject);
jmethodID mid = inEnv->GetMethodID (cls, "toString", "()V");
jthrowable exc = inEnv->ExceptionOccurred ();
if (exc) {
inEnv->ExceptionClear ();
}
CheckException (inEnv, false);
if (mid) {
jstring str = (jstring)inEnv->CallObjectMethod (cls, mid);
jboolean is_copy;
const char *utf8 = inEnv->GetStringUTFChars (str, &is_copy);
ELOG ("%s : '%s'", inMessage, utf8);
inEnv->ReleaseStringUTFChars (str, utf8);
inEnv->DeleteLocalRef (str);
} else {
ELOG ("%s : no toString in class '%s'", inMessage, ClassOf (inEnv, inObject).c_str ());
}
}
}
static void init (JNIEnv *inEnv) {
for (int i = 0; i < jniELEMENTS; i++) {
elementGetValue[i] = 0;
}
elementClass[jniBoolean] = FindClass ("java/lang/Boolean");
elementGetValue[jniBoolean] = inEnv->GetMethodID (elementClass[jniBoolean], "booleanValue", "()Z");
CheckException (inEnv, false);
elementClass[jniByte] = FindClass ("java/lang/Byte");
elementGetValue[jniByte] = inEnv->GetMethodID (elementClass[jniByte], "doubleValue", "()D");
CheckException (inEnv, false);
elementClass[jniChar] = FindClass ("java/lang/Character");
elementGetValue[jniChar] = inEnv->GetMethodID (elementClass[jniChar], "charValue", "()C");
CheckException (inEnv, false);
elementClass[jniShort] = FindClass ("java/lang/Short");
elementGetValue[jniShort] = inEnv->GetMethodID (elementClass[jniShort], "doubleValue", "()D");
CheckException (inEnv, false);
elementClass[jniInt] = FindClass ("java/lang/Integer");
elementGetValue[jniInt] = inEnv->GetMethodID (elementClass[jniInt], "doubleValue", "()D");
CheckException (inEnv, false);
elementClass[jniLong] = FindClass ("java/lang/Long");
elementGetValue[jniLong] = inEnv->GetMethodID (elementClass[jniLong], "doubleValue", "()D");
CheckException (inEnv, false);
elementClass[jniFloat] = FindClass ("java/lang/Float");
elementGetValue[jniFloat] = inEnv->GetMethodID (elementClass[jniFloat], "doubleValue", "()D");
CheckException (inEnv, false);
elementClass[jniDouble] = FindClass ("java/lang/Double");
elementGetValue[jniDouble] = inEnv->GetMethodID (elementClass[jniDouble], "doubleValue", "()D");
CheckException (inEnv, false);
elementClass[jniVoid] = 0;
for (int i = 0; i < jniELEMENTS; i++) {
JNIType type ((JNIElement)i, 1);
if (i == jniVoid) {
elementArrayClass[i] = 0;
} else {
elementArrayClass[i] = type.getClass (inEnv);
}
if (i < jniPODStart) {
elementClass[i] = JNIType ((JNIElement)i, 0).getClass (inEnv);
} else {
//ELOG("POD type %d = %p", i, elementClass[i]);
}
CheckException (inEnv, false);
}
elementGetValue[jniValueObject] = inEnv->GetMethodID (elementClass[jniValueObject], "getDouble", "()D");
}
void Misc_javaRegister()
{
class_Throwable = (*javaEnv)->FindClass(javaEnv, "java/lang/Throwable");
if(!class_Throwable)
{
Com_Error(ERR_FATAL, "Couldn't find java.lang.Throwable");
}
method_Throwable_printStackTrace = (*javaEnv)->GetMethodID(javaEnv, class_Throwable, "printStackTrace", "(Ljava/io/PrintWriter;)V");
if(!method_Throwable_printStackTrace)
{
Com_Error(ERR_FATAL, "Couldn't find java.lang.Throwable.printStackTrace() method");
}
/*
method_Throwable_fillInStackTrace = (*javaEnv)->GetMethodID(javaEnv, class_Throwable, "fillInStackTrace", "()Ljava/lang/Throwable;");
if(!method_Throwable_fillInStackTrace)
{
Com_Error(ERR_FATAL, "Couldn't find java.lang.Throwable.fillInStackTrace() method");
}
*/
method_Throwable_getMessage = (*javaEnv)->GetMethodID(javaEnv, class_Throwable, "getMessage", "()Ljava/lang/String;");
if(!method_Throwable_getMessage)
{
Com_Error(ERR_FATAL, "Couldn't find java.lang.Throwable.getMessage() method");
}
method_Throwable_toString = (*javaEnv)->GetMethodID(javaEnv, class_Throwable, "toString", "()Ljava/lang/String;");
if(!method_Throwable_toString)
{
Com_Error(ERR_FATAL, "Couldn't find java.lang.Throwable.toString() method");
}
// get class java.io.StringWriter
class_StringWriter = (*javaEnv)->FindClass(javaEnv, "java/io/StringWriter");
if(!class_StringWriter)
{
Com_Error(ERR_FATAL, "Couldn't find java.io.StringWriter");
}
method_StringWriter_ctor = (*javaEnv)->GetMethodID(javaEnv, class_StringWriter, "<init>", "()V");
if(!method_StringWriter_ctor)
{
Com_Error(ERR_FATAL, "Couldn't find java.io.StringWriter constructor method");
}
method_StringWriter_toString = (*javaEnv)->GetMethodID(javaEnv, class_StringWriter, "toString", "()Ljava/lang/String;");
if(!method_StringWriter_toString)
{
Com_Error(ERR_FATAL, "Couldn't find java.io.StringWriter.toString() method");
}
// get class java.io.PrintWriter
class_PrintWriter = (*javaEnv)->FindClass(javaEnv, "java/io/PrintWriter");
if(!class_PrintWriter)
{
Com_Error(ERR_FATAL, "Couldn't find java.io.PrintWriter");
}
method_PrintWriter_ctor = (*javaEnv)->GetMethodID(javaEnv, class_PrintWriter, "<init>", "(Ljava/io/Writer;)V");
if(!method_PrintWriter_ctor)
{
Com_Error(ERR_FATAL, "Couldn't find java.io.PrintWriter constructor method");
}
// get class java.lang.String
class_String = (*javaEnv)->FindClass(javaEnv, "java/lang/String");
if(!class_String)
{
Com_Error(ERR_FATAL, "Couldn't find java.lang.String");
}
// now that the java.lang.Class, java.lang.Throwable handles are obtained
// we can start checking for exceptions
class_Tuple3f = (*javaEnv)->FindClass(javaEnv, "javax/vecmath/Tuple3f");
if(CheckException() || !class_Tuple3f)
{
Com_Error(ERR_FATAL, "Couldn't find javax.vecmath.Tuple3f");
}
method_Tuple3f_ctor = (*javaEnv)->GetMethodID(javaEnv, class_Tuple3f, "<init>", "(FFF)V");
if(CheckException() || !method_Tuple3f_ctor)
{
Com_Error(ERR_FATAL, "Couldn't find javax.vecmath.Tuple3f constructor method");
}
class_Point3f = (*javaEnv)->FindClass(javaEnv, "javax/vecmath/Point3f");
if(CheckException() || !class_Point3f)
{
Com_Error(ERR_FATAL, "Couldn't find javax.vecmath.Point3f");
}
method_Point3f_ctor = (*javaEnv)->GetMethodID(javaEnv, class_Point3f, "<init>", "(FFF)V");
if(CheckException() || !method_Point3f_ctor)
{
Com_Error(ERR_FATAL, "Couldn't find javax.vecmath.Point3f constructor method");
}
class_Vector3f = (*javaEnv)->FindClass(javaEnv, "javax/vecmath/Vector3f");
if(CheckException() || !class_Vector3f)
{
Com_Error(ERR_FATAL, "Couldn't find javax.vecmath.Vector3f");
}
method_Vector3f_ctor = (*javaEnv)->GetMethodID(javaEnv, class_Vector3f, "<init>", "(FFF)V");
if(CheckException() || !method_Vector3f_ctor)
{
Com_Error(ERR_FATAL, "Couldn't find javax.vecmath.Vector3f constructor method");
}
class_Angle3f = (*javaEnv)->FindClass(javaEnv, "xreal/Angle3f");
if(CheckException() || !class_Angle3f)
{
Com_Error(ERR_FATAL, "Couldn't find xreal.Angle3f");
}
method_Angle3f_ctor = (*javaEnv)->GetMethodID(javaEnv, class_Angle3f, "<init>", "(FFF)V");
if(CheckException() || !method_Angle3f_ctor)
{
Com_Error(ERR_FATAL, "Couldn't find xreal.Angle3f constructor method");
}
class_Quat4f = (*javaEnv)->FindClass(javaEnv, "javax/vecmath/Quat4f");
if(CheckException() || !class_Quat4f)
{
Com_Error(ERR_FATAL, "Couldn't find javax.vecmath.Quat4f");
}
method_Quat4f_ctor = (*javaEnv)->GetMethodID(javaEnv, class_Quat4f, "<init>", "(FFFF)V");
if(CheckException() || !method_Quat4f_ctor)
{
Com_Error(ERR_FATAL, "Couldn't find javax.vecmath.Quat4f constructor method");
}
class_Trajectory = (*javaEnv)->FindClass(javaEnv, "xreal/Trajectory");
if(CheckException() || !class_Trajectory)
{
Com_Error(ERR_FATAL, "Couldn't find xreal.Trajectory");
}
// int trType, int trTime, int trDuration, float trAcceleration,
//float trBaseX, float trBaseY, float trBaseZ, float trBaseW,
//float trDeltaX, float trDeltaY, float trDeltaZ, float trDeltaW)
method_Trajectory_ctor = (*javaEnv)->GetMethodID(javaEnv, class_Trajectory, "<init>", "(IIIFFFFFFFFF)V");
if(CheckException() || !method_Trajectory_ctor)
{
Com_Error(ERR_FATAL, "Couldn't find xreal.Trajectory constructor method");
}
}
