public LocalClassReferenceHolder(JniEnvironment nativeEnvironment, jclass reference)
{
Contract.Requires<ArgumentNullException>(nativeEnvironment != null, "nativeEnvironment");
_nativeEnvironment = nativeEnvironment;
_reference = (jclass)_nativeEnvironment.NewLocalReference(reference);
}
private static jthread alloc_thread(JNIEnvHandle jniEnv)
{
jniNativeInterface nativeInterface = (jniNativeInterface)Marshal.PtrToStructure(Marshal.ReadIntPtr(jniEnv.Handle), typeof(jniNativeInterface));
jclass @class = nativeInterface.FindClass(jniEnv, "java/lang/Thread");
if (@class == jclass.Null)
{
throw new Exception("ERROR: JNI: Cannot find %s with FindClass.");
}
nativeInterface.ExceptionClear(jniEnv);
jmethodID method = nativeInterface.GetMethodID(jniEnv, @class, "<init>", "()V");
if (method == jmethodID.Null)
{
throw new Exception("Cannot find Thread constructor method.");
}
nativeInterface.ExceptionClear(jniEnv);
jthread result = (jthread)nativeInterface.NewObject(jniEnv, @class, method);
if (result == jthread.Null)
{
throw new Exception("Cannot create new Thread object");
}
nativeInterface.ExceptionClear(jniEnv);
return(result);
}
public jmethodID* GetMethodID(jclass* clazz, string name, string sig)
{
if (getMethodID == null)
{
Util.GetDelegateForFunctionPointer(functions.GetMethodID, ref getMethodID);
}
return getMethodID.Invoke(real, clazz, name, sig);
}
static PrintStream()
{
var setup = JNetHost.Run(runtime =>
{
var clz_PrintStream = runtime.FindClass("java/io/PrintStream");
var mid_println_A = runtime.GetMethodID(clz_PrintStream, "println", "(Ljava/lang/String;)V");
clz_PrintStream = (jclass)runtime.NewGlobalRef(clz_PrintStream);
return(clz_PrintStream, mid_println_A);
});
clz_PrintStream = setup.clz_PrintStream;
mid_println_A = setup.mid_println_A;
}
static System()
{
var setup = JNetHost.Run(runtime => {
var clz_System = runtime.FindClass("java/lang/System");
var fid_out = runtime.GetStaticFieldID(clz_System, "out", "Ljava/io/PrintStream;");
var mid_getProperty = runtime.GetStaticMethodID(clz_System, "getProperty", "(Ljava/lang/String;)Ljava/lang/String;");
clz_System = (jclass)runtime.NewGlobalRef(clz_System);
return(clz_System, fid_out, mid_getProperty);
});
clz_System = setup.clz_System;
fid_out = setup.fid_out;
mid_getProperty = setup.mid_getProperty;
}
// JVM load the .so and calls this native function
static jlong Java_HybridOculusVrActivity_OVRJVM_ApplicationActivity_nativeSetAppInterface(
ref JNIEnv env,
jclass clazz,
jobject activity,
jstring fromPackageNameString, jstring commandString, jstring uriString
)
{
log.__android_log_print(log.android_LogPriority.ANDROID_LOG_INFO, "xNativeActivity", "enter Java_HybridOculusVrActivity_OVRJVM_ApplicationActivity_nativeSetAppInterface");
//jni/HybridOculusVrActivity.dll.c: In function 'Java_HybridOculusVrActivity_OVRJVM_ApplicationActivity_nativeSetAppInterface':
//jni/HybridOculusVrActivity.dll.c:64:5: error: format not a string literal and no format arguments [-Werror=format-security]
//android_native_app_glue.app_dummy();
//var x = OvrApp.cxxGetString();
//android_native_app_glue.app_dummy();
//log.__android_log_print(log.android_LogPriority.ANDROID_LOG_INFO, "xNativeActivity", x);
// return (new OvrApp())->SetActivity( jni, clazz, activity );
//I/System.Console(13696): enter HybridOculusVrActivity.OVRJVM ApplicationActivity onCreate
//I/xNativeActivity(13696): enter Java_HybridOculusVrActivity_OVRJVM_ApplicationActivity_stringFromJNI
//I/xNativeActivity(13696): enter Java_HybridOculusVrActivity_OVRJVM_ApplicationActivity_nativeSetAppInterface
// http://stackoverflow.com/questions/7281441/elegantly-call-c-from-c
//long u = 0;
return(OvrApp.cxxSetAppInterface(
ref env,
clazz,
activity,
// added by oculus050
fromPackageNameString, commandString, uriString
));
}
public jclass GetSuperclass(jclass @class)
{
jclass result = RawInterface.GetSuperclass(this, @class);
HandleException();
return result;
}
private void HandleClassFileLoadHook(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jclass classBeingRedefinedHandle, jobject loaderHandle, ModifiedUTF8StringData name, jobject protectionDomainHandle, int classDataLength, IntPtr classData, ref int newClassDataLength, ref IntPtr newClassData)
{
JvmEnvironment environment = JvmEnvironment.GetEnvironment(env);
JvmClassReference classBeingRedefined = JvmClassReference.FromHandle(environment, jniEnv, classBeingRedefinedHandle, true);
JvmObjectReference loader = JvmObjectReference.FromHandle(environment, jniEnv, loaderHandle, true);
JvmObjectReference protectionDomain = JvmObjectReference.FromHandle(environment, jniEnv, protectionDomainHandle, true);
foreach (var processor in _processors)
{
processor.HandleClassFileLoadHook(environment, classBeingRedefined, loader, name.GetString(), protectionDomain);
}
}
private void HandleClassLoad(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jclass classHandle)
{
//JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env);
//JniEnvironment nativeEnvironment;
//JniErrorHandler.ThrowOnFailure(VirtualMachine.AttachCurrentThreadAsDaemon(environment, out nativeEnvironment, false));
//VirtualMachine.HandleClassLoad(environment, nativeEnvironment, classHandle);
}
public jvmtiError GetFieldModifiers(jclass classHandle, FieldId fieldId, out JvmAccessModifiers modifiers)
{
return RawInterface.GetFieldModifiers(this, classHandle, fieldId, out modifiers);
}
public jvmtiError GetFieldName(jclass classHandle, FieldId fieldId, out string name, out string signature, out string genericSignature)
{
name = null;
signature = null;
genericSignature = null;
IntPtr namePtr;
IntPtr signaturePtr;
IntPtr genericPtr;
jvmtiError error = RawInterface.GetFieldName(this, classHandle, fieldId, out namePtr, out signaturePtr, out genericPtr);
if (error != jvmtiError.None)
return error;
try
{
unsafe
{
if (namePtr != IntPtr.Zero)
name = ModifiedUTF8Encoding.GetString((byte*)namePtr);
if (signaturePtr != IntPtr.Zero)
signature = ModifiedUTF8Encoding.GetString((byte*)signaturePtr);
if (genericPtr != IntPtr.Zero)
genericSignature = ModifiedUTF8Encoding.GetString((byte*)genericPtr);
}
}
finally
{
Deallocate(namePtr);
Deallocate(signaturePtr);
Deallocate(genericPtr);
}
return jvmtiError.None;
}
public jvmtiError GetImplementedInterfaces(JniEnvironment nativeEnvironment, jclass classHandle, out TaggedReferenceTypeId[] interfaces)
{
interfaces = null;
int interfacesCount;
IntPtr interfacesPtr;
jvmtiError error = RawInterface.GetImplementedInterfaces(this, classHandle, out interfacesCount, out interfacesPtr);
if (error != jvmtiError.None)
return error;
try
{
List<TaggedReferenceTypeId> interfaceList = new List<TaggedReferenceTypeId>();
unsafe
{
jclass* interfaceHandles = (jclass*)interfacesPtr;
for (int i = 0; i < interfacesCount; i++)
{
if (interfaceHandles[i] == jclass.Null)
continue;
interfaceList.Add(VirtualMachine.TrackLocalClassReference(interfaceHandles[i], this, nativeEnvironment, true));
}
}
interfaces = interfaceList.ToArray();
return jvmtiError.None;
}
finally
{
Deallocate(interfacesPtr);
}
}
public jvmtiError IsInterface(jclass classHandle, out bool result)
{
byte isInterface;
jvmtiError error = RawInterface.IsInterface(this, classHandle, out isInterface);
result = isInterface != 0;
return error;
}
private void HandleVMObjectAlloc(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jobject objectHandle, jclass objectClassHandle, long size)
{
JvmEnvironment environment = JvmEnvironment.GetEnvironment(env);
JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true);
JvmObjectReference @object = JvmObjectReference.FromHandle(environment, jniEnv, objectHandle, true);
JvmClassReference objectClass = JvmClassReference.FromHandle(environment, jniEnv, objectClassHandle, true);
foreach (var processor in _processors)
{
processor.HandleVMObjectAllocation(environment, thread, @object, objectClass, size);
}
}
private void HandleFieldModification(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID method, jlocation jlocation, jclass fieldClassHandle, jobject @objectHandle, jfieldID fieldId, byte signatureType, jvalue newValue)
{
JvmEnvironment environment = JvmEnvironment.GetEnvironment(env);
JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true);
JvmLocation location = new JvmLocation(environment, method, jlocation);
JvmClassReference fieldClass = JvmClassReference.FromHandle(environment, jniEnv, fieldClassHandle, true);
JvmObjectReference @object = JvmObjectReference.FromHandle(environment, jniEnv, objectHandle, true);
JvmField field = new JvmField(environment, fieldId);
foreach (var processor in _processors)
{
processor.HandleFieldModification(environment, thread, location, fieldClass, @object, field, signatureType, newValue);
}
}
private void HandleClassPrepare(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jclass classHandle)
{
JvmEnvironment environment = JvmEnvironment.GetEnvironment(env);
JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true);
JvmClassReference @class = JvmClassReference.FromHandle(environment, jniEnv, classHandle, true);
foreach (var processor in _processors)
{
processor.HandleClassPrepare(environment, thread, @class);
}
}
// JVM load the .so and calls this native function
static jlong Java_HybridOculusVrActivity_OVRJVM_ApplicationActivity_nativeSetAppInterface(
ref JNIEnv env,
jclass clazz,
jobject activity,
jstring fromPackageNameString, jstring commandString, jstring uriString
)
{
log.__android_log_print(log.android_LogPriority.ANDROID_LOG_INFO, "xNativeActivity", "enter Java_HybridOculusVrActivity_OVRJVM_ApplicationActivity_nativeSetAppInterface");
//jni/HybridOculusVrActivity.dll.c: In function 'Java_HybridOculusVrActivity_OVRJVM_ApplicationActivity_nativeSetAppInterface':
//jni/HybridOculusVrActivity.dll.c:64:5: error: format not a string literal and no format arguments [-Werror=format-security]
//android_native_app_glue.app_dummy();
//var x = OvrApp.cxxGetString();
//android_native_app_glue.app_dummy();
//log.__android_log_print(log.android_LogPriority.ANDROID_LOG_INFO, "xNativeActivity", x);
// return (new OvrApp())->SetActivity( jni, clazz, activity );
//I/System.Console(13696): enter HybridOculusVrActivity.OVRJVM ApplicationActivity onCreate
//I/xNativeActivity(13696): enter Java_HybridOculusVrActivity_OVRJVM_ApplicationActivity_stringFromJNI
//I/xNativeActivity(13696): enter Java_HybridOculusVrActivity_OVRJVM_ApplicationActivity_nativeSetAppInterface
// http://stackoverflow.com/questions/7281441/elegantly-call-c-from-c
//long u = 0;
return OvrApp.cxxSetAppInterface(
ref env,
clazz,
activity,
// added by oculus050
fromPackageNameString, commandString, uriString
);
}
public jvmtiError GetFieldDeclaringClass(JniEnvironment nativeEnvironment, jclass classHandle, FieldId fieldId, out TaggedReferenceTypeId declaringClass)
{
declaringClass = default(TaggedReferenceTypeId);
jclass declaringClassHandle;
jvmtiError error = RawInterface.GetFieldDeclaringClass(this, classHandle, fieldId, out declaringClassHandle);
if (error != jvmtiError.None)
return error;
declaringClass = VirtualMachine.TrackLocalClassReference(declaringClassHandle, this, nativeEnvironment, true);
return jvmtiError.None;
}
private void HandleVMObjectAlloc(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jobject objectHandle, jclass objectClassHandle, long size)
{
if (!VirtualMachine.IsAgentThread.Value)
{
// ignore events before VMInit
if (AgentEventDispatcher == null)
return;
// dispatch this call to an agent thread
Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jobject, jclass, long> method = HandleVMObjectAlloc;
AgentEventDispatcher.Invoke(method, env, jniEnv, threadHandle, objectHandle, objectClassHandle, size);
return;
}
//JvmEnvironment environment = JvmEnvironment.GetEnvironment(env);
//JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true);
//JvmObjectReference @object = JvmObjectReference.FromHandle(environment, jniEnv, objectHandle, true);
//JvmClassReference objectClass = JvmClassReference.FromHandle(environment, jniEnv, objectClassHandle, true);
//foreach (var processor in _processors)
//{
// processor.HandleVMObjectAllocation(environment, thread, @object, objectClass, size);
//}
}
public static JvmClassReference FromHandle(JvmEnvironment environment, JNIEnvHandle jniEnv, jclass classHandle, bool freeLocalReference)
{
if (classHandle == jclass.Null)
{
return(null);
}
JvmNativeEnvironment nativeEnvironment = environment.GetNativeFunctionTable(jniEnv);
return(new JvmClassReference(environment, nativeEnvironment, classHandle, freeLocalReference));
}
// JVM load the .so and calls this native function
static long Java_OVROculus360Photos_Activities_xMarshal_nativeSetAppInterface(
JNIEnv env,
jclass clazz,
// ApplicationActivity : com.oculus.vrappframework.VrActivity
jobject activity,
jstring fromPackageNameString,
jstring commandString,
jstring uriString
)
{
// can we do typeof() yet and have our env from there?
// Error 3 No overload for method '__android_log_print' takes 3 arguments X:\jsc.svn\examples\java\android\synergy\OVROculus360PhotosNDK\OVROculus360PhotosNDK\xNativeActivity.cs 39 13 OVROculus360PhotosNDK
// https://sites.google.com/a/jsc-solutions.net/work/knowledge-base/15-dualvr/20150721/ovroculus360photoshud
ScriptCoreLibAndroidNDK.Library.ConsoleExtensions.trace("enter Java_OVROculus360Photos_Activities_xMarshal_nativeSetAppInterface");
//Oculus360Photos_h.AtStartBackgroundPanoLoad = new object();
xNativeAtStartBackgroundPanoLoad = xNativeAtStartBackgroundPanoLoadInvoke;
//xNativeAtStartBackgroundPanoLoad("not yet loaded", null);
var loctype = env.GetObjectClass(env, activity);
var gtype = (jclass)env.NewGlobalRef(env, loctype);
//var gtype = (jclass)env.NewGlobalRef<jclass>(env, loctype);
var typeof_this = new __Type { arg0_env = env, arg1_type = gtype };
//var setDefaultLocale = typeof_this.GetMethodID("setDefaultLocale", "()V");
var setDefaultLocale = typeof_this.GetMethod("setDefaultLocale", "()V");
//var setDefaultLocale = env.GetMethodID(env, loctype, "setDefaultLocale", "()V");
//Type.GetMethod();
ConsoleExtensions.tracei64("setDefaultLocale: ", (int)(object)setDefaultLocale);
// I/xNativeActivity(24350): [3194400] \xNativeActivity.cs:202 enter Java_OVROculus360Photos_Activities_xMarshal_nativeSetAppInterface
//I/xNativeActivity(24350): [3194400] \xNativeActivity.cs:222 setDefaultLocale: -2012160456
// public virtual void setDefaultLocale()
//env.NewStringUTF(env, "en");
// error: undefined reference to '__new_jvalue'
// env.CallVoidMethodA(env, activity, setDefaultLocale, args: default(jvalue[]));
setDefaultLocale.Invoke(activity);
return Oculus360Photos_h.Java_com_oculus_oculus360photossdk_MainActivity_nativeSetAppInterface(
env,
//clazz,
gtype,
activity,
fromPackageNameString,
commandString,
uriString,
arg_AtStartBackgroundPanoLoad: xNativeAtStartBackgroundPanoLoad
);
}
internal JvmClassReference(JvmEnvironment environment, JvmNativeEnvironment nativeEnvironment, jclass handle, bool freeLocalReference)
: base(environment, nativeEnvironment, handle, freeLocalReference)
{
}
internal jobject NewObjectArray(int length, jclass elementType, jobject initialElement)
{
var result = RawInterface.NewObjectArray(this, length, elementType, initialElement);
HandleException();
return result;
}
// JVM load the .so and calls this native function
static long Java_OVROculus360Photos_Activities_xMarshal_nativeSetAppInterface(
JNIEnv env,
jclass clazz,
// ApplicationActivity : com.oculus.vrappframework.VrActivity
jobject activity,
jstring fromPackageNameString,
jstring commandString,
jstring uriString
)
{
// can we do typeof() yet and have our env from there?
// Error 3 No overload for method '__android_log_print' takes 3 arguments X:\jsc.svn\examples\java\android\synergy\OVROculus360PhotosNDK\OVROculus360PhotosNDK\xNativeActivity.cs 39 13 OVROculus360PhotosNDK
// https://sites.google.com/a/jsc-solutions.net/work/knowledge-base/15-dualvr/20150721/ovroculus360photoshud
ScriptCoreLibAndroidNDK.Library.ConsoleExtensions.trace("enter Java_OVROculus360Photos_Activities_xMarshal_nativeSetAppInterface");
//Oculus360Photos_h.AtStartBackgroundPanoLoad = new object();
xNativeAtStartBackgroundPanoLoad = xNativeAtStartBackgroundPanoLoadInvoke;
//xNativeAtStartBackgroundPanoLoad("not yet loaded", null);
var loctype = env.GetObjectClass(env, activity);
var gtype = (jclass)env.NewGlobalRef(env, loctype);
//var gtype = (jclass)env.NewGlobalRef<jclass>(env, loctype);
var typeof_this = new __Type {
arg0_env = env, arg1_type = gtype
};
//var setDefaultLocale = typeof_this.GetMethodID("setDefaultLocale", "()V");
var setDefaultLocale = typeof_this.GetMethod("setDefaultLocale", "()V");
//var setDefaultLocale = env.GetMethodID(env, loctype, "setDefaultLocale", "()V");
//Type.GetMethod();
ConsoleExtensions.tracei64("setDefaultLocale: ", (int)(object)setDefaultLocale);
// I/xNativeActivity(24350): [3194400] \xNativeActivity.cs:202 enter Java_OVROculus360Photos_Activities_xMarshal_nativeSetAppInterface
//I/xNativeActivity(24350): [3194400] \xNativeActivity.cs:222 setDefaultLocale: -2012160456
// public virtual void setDefaultLocale()
//env.NewStringUTF(env, "en");
// error: undefined reference to '__new_jvalue'
// env.CallVoidMethodA(env, activity, setDefaultLocale, args: default(jvalue[]));
setDefaultLocale.Invoke(activity);
return(Oculus360Photos_h.Java_com_oculus_oculus360photossdk_MainActivity_nativeSetAppInterface(
env,
//clazz,
gtype,
activity,
fromPackageNameString,
commandString,
uriString,
arg_AtStartBackgroundPanoLoad: xNativeAtStartBackgroundPanoLoad
));
}
public bool IsInstanceOf(jobject @object, jclass @class)
{
byte result = RawInterface.IsInstanceOf(this, @object, @class);
HandleException();
return result != 0;
}
// defined at
// X:\opensource\ovr_mobile_sdk_0.6.0.1\VrSamples\Native\Oculus360PhotosSDK\jni\Oculus360Photos.cpp
// https://sites.google.com/a/jsc-solutions.net/work/knowledge-base/15-dualvr/20150721/ovroculus360photoshud
//public static object AtStartBackgroundPanoLoad;
public static long Java_com_oculus_oculus360photossdk_MainActivity_nativeSetAppInterface(JNIEnv env,
jclass clazz,
jobject activity,
jstring fromPackageNameString,
jstring commandString,
jstring uriString,
object arg_AtStartBackgroundPanoLoad
)
{
return(0);
}
public JNIResult RegisterNatives(jclass* clazz, JNINativeMethod* methods, int nMethods)
{
if (registerNatives == null)
{
Util.GetDelegateForFunctionPointer(functions.RegisterNatives, ref registerNatives);
}
return registerNatives.Invoke(real, clazz, methods, nMethods);
}
public jobject NewObject(jclass @class, jmethodID ctorMethodId, params jvalue[] args)
{
jobject result = RawInterface.NewObjectA(this, @class, ctorMethodId, args);
HandleException();
return result;
}
public JvmClassRemoteHandle(jclass @class)
{
Handle = @class.Handle.ToInt64();
}
public jmethodID GetMethodId(jclass @class, string name, string signature)
{
jmethodID result = RawInterface.GetMethodID(this, @class, name, signature);
HandleException();
return result;
}
public JvmClassRemoteHandle(jclass @class)
{
Handle = @class.Handle.ToInt64();
}
internal bool GetStaticBooleanField(jclass classHandle, jfieldID fieldId)
{
bool result = RawInterface.GetStaticBooleanField(this, classHandle, fieldId) != 0;
HandleException();
return result;
}
//jlong cxxSetAppInterface(JNIEnv* jni, jclass clazz, jobject activity);
public static jlong cxxSetAppInterface(ref JNIEnv jni, jclass c, jobject activity,
jstring fromPackageNameString, jstring commandString, jstring uriString)
{ return (jlong)(object)0; }
internal double GetStaticDoubleField(jclass classHandle, jfieldID fieldId)
{
var result = RawInterface.GetStaticDoubleField(this, classHandle, fieldId);
HandleException();
return result;
}
//jlong cxxSetAppInterface(JNIEnv* jni, jclass clazz, jobject activity);
public static jlong cxxSetAppInterface(ref JNIEnv jni, jclass c, jobject activity,
jstring fromPackageNameString, jstring commandString, jstring uriString)
{
return((jlong)(object)0);
}
internal jobject GetStaticObjectField(jclass classHandle, jfieldID fieldId)
{
var result = RawInterface.GetStaticObjectField(this, classHandle, fieldId);
HandleException();
return result;
}
private void HandleFieldModification(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, jlocation jlocation, jclass fieldClassHandle, jobject objectHandle, jfieldID fieldId, byte signatureType, jvalue newValue)
{
if (!VirtualMachine.IsAgentThread.Value)
{
// ignore events before VMInit
if (AgentEventDispatcher == null)
return;
// dispatch this call to an agent thread
Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jmethodID, jlocation, jclass, jobject, jfieldID, byte, jvalue> method = HandleFieldModification;
AgentEventDispatcher.Invoke(method, env, jniEnv, threadHandle, methodId, jlocation, fieldClassHandle, objectHandle, fieldId, signatureType, newValue);
return;
}
//JvmEnvironment environment = JvmEnvironment.GetEnvironment(env);
//JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true);
//JvmLocation location = new JvmLocation(environment, method, jlocation);
//JvmClassReference fieldClass = JvmClassReference.FromHandle(environment, jniEnv, fieldClassHandle, true);
//JvmObjectReference @object = JvmObjectReference.FromHandle(environment, jniEnv, objectHandle, true);
//JvmField field = new JvmField(environment, fieldId);
//foreach (var processor in _processors)
//{
// processor.HandleFieldModification(environment, thread, location, fieldClass, @object, field, signatureType, newValue);
//}
}
internal bool CallStaticBooleanMethodA(jclass classHandle, jmethodID methodId, params jvalue[] args)
{
var result = RawInterface.CallStaticBooleanMethodA(this, classHandle, methodId, args) != 0;
HandleException();
return result;
}
private void HandleClassFileLoadHook(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jclass classBeingRedefinedHandle, jobject loaderHandle, IntPtr name, jobject protectionDomainHandle, int classDataLength, IntPtr classData, ref int newClassDataLength, ref IntPtr newClassData)
{
// need to extract the exception_table for each method
ClassFile classFile = ClassFile.FromMemory(classData, 0);
ConstantClass constantClass = classFile.ThisClass;
ConstantUtf8 constantClassSignature = (ConstantUtf8)classFile.ConstantPool[constantClass.NameIndex - 1];
string classSignature = constantClassSignature.Value;
if (classSignature[0] != '[')
classSignature = 'L' + classSignature + ';';
long classLoaderTag;
JvmtiErrorHandler.ThrowOnFailure(Environment.TagClassLoader(loaderHandle, out classLoaderTag));
foreach (var methodInfo in classFile.Methods)
{
if ((methodInfo.Modifiers & (AccessModifiers.Abstract | AccessModifiers.Native)) != 0)
continue;
Code codeAttribute = methodInfo.Attributes.OfType<Code>().SingleOrDefault();
if (codeAttribute == null)
continue;
ConstantUtf8 constantMethodName = (ConstantUtf8)classFile.ConstantPool[methodInfo.NameIndex - 1];
string methodName = constantMethodName.Value;
ConstantUtf8 constantMethodSignature = (ConstantUtf8)classFile.ConstantPool[methodInfo.DescriptorIndex - 1];
string methodSignature = constantMethodSignature.Value;
VirtualMachine.SetExceptionTable(classLoaderTag, classSignature, methodName, methodSignature, codeAttribute.ExceptionTable);
}
#if false
if (!VirtualMachine.IsAgentThread.Value)
{
// ignore events before VMInit
if (AgentEventDispatcher == null)
return;
// dispatch this call to an agent thread
//Action<jvmtiEnvHandle, JNIEnvHandle, jclass, jobject, ModifiedUTF8StringData, jobject, int, IntPtr> method = HandleClassFileLoadHook;
//AgentEventDispatcher.Invoke(method, env, jniEnv);
//return;
throw new NotImplementedException();
}
//JvmEnvironment environment = JvmEnvironment.GetEnvironment(env);
//JvmClassReference classBeingRedefined = JvmClassReference.FromHandle(environment, jniEnv, classBeingRedefinedHandle, true);
//JvmObjectReference loader = JvmObjectReference.FromHandle(environment, jniEnv, loaderHandle, true);
//JvmObjectReference protectionDomain = JvmObjectReference.FromHandle(environment, jniEnv, protectionDomainHandle, true);
//foreach (var processor in _processors)
//{
// processor.HandleClassFileLoadHook(environment, classBeingRedefined, loader, name.GetString(), protectionDomain);
//}
#endif
}
internal jobject CallStaticObjectMethodA(jclass classHandle, jmethodID methodId, params jvalue[] args)
{
var result = RawInterface.CallStaticObjectMethodA(this, classHandle, methodId, args);
HandleException();
return result;
}
private void HandleClassPrepare(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jclass classHandle)
{
bool preventSuspend = VirtualMachine.IsAgentThread.Value;
JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env);
JniEnvironment nativeEnvironment = JniEnvironment.GetOrCreateInstance(jniEnv);
string signature;
IntPtr signaturePtr;
IntPtr genericPtr;
JvmtiErrorHandler.ThrowOnFailure(RawInterface.GetClassSignature(env, classHandle, out signaturePtr, out genericPtr));
try
{
unsafe
{
signature = ModifiedUTF8Encoding.GetString((byte*)signaturePtr);
}
}
finally
{
RawInterface.Deallocate(env, signaturePtr);
RawInterface.Deallocate(env, genericPtr);
}
ClassStatus classStatus = 0;
jvmtiClassStatus internalClassStatus;
JvmtiErrorHandler.ThrowOnFailure(RawInterface.GetClassStatus(env, classHandle, out internalClassStatus));
if ((internalClassStatus & jvmtiClassStatus.Error) != 0)
classStatus |= ClassStatus.Error;
if ((internalClassStatus & jvmtiClassStatus.Initialized) != 0)
classStatus |= ClassStatus.Initialized;
if ((internalClassStatus & jvmtiClassStatus.Prepared) != 0)
classStatus |= ClassStatus.Prepared;
if ((internalClassStatus & jvmtiClassStatus.Verified) != 0)
classStatus |= ClassStatus.Verified;
ThreadId threadId = VirtualMachine.TrackLocalThreadReference(threadHandle, environment, nativeEnvironment, false);
TaggedReferenceTypeId classId = VirtualMachine.TrackLocalClassReference(classHandle, environment, nativeEnvironment, false);
EventFilter[] filters = GetEventFilters(EventKind.ClassPrepare);
foreach (var filter in filters)
{
if (filter.ProcessEvent(environment, nativeEnvironment, this, threadId, classId, default(Location?)))
{
SendClassPrepareEvent(environment, filter, threadId, classId, signature, classStatus, preventSuspend);
}
}
}
internal void CallNonvirtualVoidMethodA(jobject instanceHandle, jclass classHandle, jmethodID methodId, params jvalue[] args)
{
RawInterface.CallNonvirtualVoidMethodA(this, instanceHandle, classHandle, methodId, args);
HandleException();
}
// defined at
// X:\opensource\ovr_mobile_sdk_0.6.0.1\VrSamples\Native\Oculus360PhotosSDK\jni\Oculus360Photos.cpp
// https://sites.google.com/a/jsc-solutions.net/work/knowledge-base/15-dualvr/20150721/ovroculus360photoshud
//public static object AtStartBackgroundPanoLoad;
public static long Java_com_oculus_oculus360photossdk_MainActivity_nativeSetAppInterface(JNIEnv env,
jclass clazz,
jobject activity,
jstring fromPackageNameString,
jstring commandString,
jstring uriString,
object arg_AtStartBackgroundPanoLoad
) { return 0; }
internal jobject CallNonvirtualObjectMethodA(jobject instanceHandle, jclass classHandle, jmethodID methodId, params jvalue[] args)
{
var result = RawInterface.CallNonvirtualObjectMethodA(this, instanceHandle, classHandle, methodId, args);
HandleException();
return result;
}
