private static void HookStream(JniEnvironment environment, JniClass nativeClazz,
JavaVMLogTypes hook, string javaHookMethod)
{
JniMethod outMid = nativeClazz.GetStaticMethodId(environment, javaHookMethod, "(I)V");
JValue[] paramArray = new JValue[1];
paramArray[0].AssignIntValue((int)hook);
outMid.CallStaticVoidMethod(environment, paramArray);
}
protected JniMember(IntPtr handle, JniClass declaringClass, bool isStatic, string signature)
{
if (handle == IntPtr.Zero)
{
throw new JniException("TODO");
}
VerifyInputJniObject(declaringClass);
mHandle = handle;
mDeclaringClass = declaringClass;
mIsStatic = isStatic;
// TODO - refactor this mess
string returnType = signature.Trim();
int pos = returnType.LastIndexOf(')');
if (pos > -1)
returnType = returnType.Substring(pos + 1);
pos = returnType.LastIndexOf('[');
mArrayRank = -1;
string type = returnType;
if (pos > -1)
{
mArrayRank = pos + 1;
type = type.Substring(pos + 1);
}
if (type.Length == 1)
{
if (type == "V")
{
mJniType = JniType.Void;
}
else
{
mJniType = CsJni.JniArray.ParseArrayPrimitiveType(type);
if (mJniType == JniType.Null)
{
throw new JniException("TODO");
}
}
}
else
{
if (!(type.StartsWith("L", StringComparison.Ordinal) && type.EndsWith(";", StringComparison.Ordinal)))
{
throw new JniException("TODO");
}
switch (type)
{
case "Ljava/lang/String;": mJniType = JniType.String; break;
case "Ljava/lang/Class;": mJniType = JniType.Class; break;
case "Ljava/lang/Throwable;": mJniType = JniType.Throwable; break;
default: mJniType = JniType.NonPrimitive; break;
}
}
}
public static bool IsAssignableFrom(
JniEnvironment environment,
JniClass subclass,
JniClass superclass
)
{
VerifyEnvironment(environment);
VerifyInputJniObject(subclass);
VerifyInputJniObject(superclass);
byte result = JniEnvironment.Functions.IsAssignableFrom(environment.Handle, subclass.Handle, superclass.Handle);
JniThrowable.CheckException(environment);
return JBooleanConverter.From(result);
}
public static JniObjectArray NewObjectArray(
JniEnvironment environment,
int length,
JniClass jniClass,
JniObject init
)
{
VerifyEnvironment(environment);
VerifyInputJniObject(jniClass);
IntPtr safeInit = (init == null) ? IntPtr.Zero : init.Handle; // OK if initial value is null
IntPtr result = JniEnvironment.Functions.NewObjectArray(environment.Handle, length, jniClass.Handle, safeInit);
if (IntPtr.Zero == result)
{
JniThrowable.ThrowCurrentException(environment); // null result means an exception occurred
}
// EXCEPTION CHECK: Do nothing, already checked for exception above.
return new JniObjectArray(environment, result, JniObjectLifecycle.Local, -1, JniType.Null);
}
internal static void RegisterCounterpart(JniEnvironment environment, JniClass peer, Type counterpartType)
{
JniNativeMethodHolder nmHolder = new JniNativeMethodHolder();
nmHolder.PopulateFromType(counterpartType);
if (nmHolder.Count > 0)
{
peer.RegisterNatives(environment, nmHolder);
}
}
private static void RegisterNativeMethods(/* JNIEnv */ IntPtr environmentHandle,
/* jobject */ IntPtr selfHandle, IntPtr /*jclass*/ declaringClassHandle)
{
JniEnvironment environment = JavaVM.EnvironmentFromHandle(environmentHandle);
try
{
JniClass peerClass = new JniClass(environment, declaringClassHandle, JniObjectLifecycle.LocalJ2N);
string peerClassName = peerClass.GetTypeName(environment);
Type counterpartType;
if (!JavaVM.JavaNativeMethodRegistrar.mCounterpartMap.TryGetValue(peerClassName, out counterpartType))
{
throw new JniException("Found no counterpart for: " + peerClassName);
}
JavaVM.Log("Registering natives for peer: " + peerClassName + ", counterpart class: " + counterpartType.AssemblyQualifiedName);
RegisterCounterpart(environment, peerClass, counterpartType);
}
catch (JniThrowableException ex)
{
ex.Throwable.ThrowToJavaVM(environment);
}
catch (Exception ex)
{
JniThrowable.ThrowNewToJavaVM(environment,
JniClass.FindClass(environment, "java.lang.UnsatisfiedLinkError"),
JniThrowable.ExtractDotNetExceptionMessage(ex));
}
}
public static void ThrowNewToJavaVM(
JniEnvironment environment,
JniClass jniClass,
string message
)
{
VerifyInputJniObject(jniClass);
int result = JniEnvironment.Functions.ThrowNew(environment.Handle, jniClass.Handle, message);
if (0 != result)
{
JniException.CheckErrorCode(environment, result);
}
// EXCEPTION CHECK: Do nothing, already checked for exception above.
}
internal JniMethod(IntPtr handle, JniClass declaringClass, bool isStatic, string signature)
: base(handle, declaringClass, isStatic, signature)
{
}
private static string[] GetJavaPropertyNames(JniEnvironment environment, JniClass systemClazz)
{
JniLocalFrame frame = environment.CreateLocalFrame(6);
try
{
JniMethod getPropsMid = systemClazz.GetStaticMethodId(environment, "getProperties", "()Ljava/util/Properties;");
JniObject propsHandle = getPropsMid.CallStaticObjectMethod(environment, null);
JniClass propsClazz = propsHandle.GetObjectClass(environment);
JniMethod keySetId = propsClazz.GetMethodId(environment, "keySet", "()Ljava/util/Set;");
JniObject setHandle = keySetId.CallObjectMethod(environment, propsHandle, null);
JniClass setClazz = setHandle.GetObjectClass(environment);
JniMethod toArrayId = setClazz.GetMethodId(environment, "toArray", "()[Ljava/lang/Object;");
JniObjectArray arrayHandle = (JniObjectArray)toArrayId.CallObjectMethod(environment, setHandle, null);
string[] keyNames = JniString.ExtractStringArray(environment, arrayHandle);
return keyNames;
}
finally
{
frame.SafePop();
}
}
internal JniConstructor(IntPtr handle, JniClass declaringClass, string signature)
: base(handle, declaringClass, false, signature)
{
}
private static void FaultStatics(JniEnvironment environment)
{
if (!mStaticsInitialized)
{
mStaticsInitialized = true;
mStringClass = (JniClass)JniClass.FindClass(environment, "java/lang/String").NewGlobalAutoReleaseAndReleaseThis(environment);
Console.Out.WriteLine("String class: " + mStringClass.Handle); // TODO
}
}
public bool IsInstanceOf(
JniEnvironment environment,
JniClass jniClass
)
{
VerifyEnvironment(environment);
VerifyInputJniObject(jniClass);
byte result = JniEnvironment.Functions.IsInstanceOf(environment.Handle, this.Handle, jniClass.Handle);
JniThrowable.CheckException(environment);
return JBooleanConverter.From(result);
}
