public static T WrapIJavaObject <T>(JniLocalHandle handle) where T : class, IJavaObject
{
if (JniHandle.IsNull(handle))
{
return(null);
}
// see if we can find the appropriate class instance
Type type = typeof(T);
string className = type.FullName;
JNIEnv env = JNIEnv.ThreadEnv;
JniLocalHandle clazz = env.GetObjectClass(handle);
Wrapper wrapper = GetWrapper(env, clazz);
if (!wrapper.Type.GetInterfaces().Contains(typeof(T)))
{
// failed to find the instance, so let's go with the interface wrapper
wrapper = GetWrapper(className + "_");
}
var ret = wrapper.Constructor.Invoke(new object[] { env }) as T;
ret.Init(env, handle);
return(ret);
}
public static object WrapJavaObjectSealedClass(JniHandle handle, Type type)
{
if (JniHandle.IsNull(handle))
{
return(null);
}
Wrapper wrapper = GetWrapper(type.FullName);
return(wrapper.Constructor.Invoke(null));
}
public JniLocalHandle GetObjectClass(JniHandle obj)
{
if (JniHandle.IsNull(obj))
{
return(JniLocalHandle.Zero);
}
JniLocalHandle res = getObjectClass.Invoke(envPtr, obj);
ExceptionTest();
return(res);
}
internal JniLocalHandle NewLocalRef(JniHandle lobj)
{
if (JniHandle.IsNull(lobj))
{
throw new ArgumentNullException("lobj");
}
JniLocalHandle res = newLocalRef(envPtr, lobj);
//optimized away ExceptionTest();
return(res);
}
public static string GetObjectClassName(JniHandle handle)
{
if (JniHandle.IsNull(handle))
{
return(null);
}
JNIEnv env = JNIEnv.ThreadEnv;
var classHandle = env.GetObjectClass(handle);
return(GetClassName(env, classHandle));
}
public static JavaException WrapJavaException(JniLocalHandle handle)
{
if (JniHandle.IsNull(handle))
{
return(null);
}
JNIEnv env = JNIEnv.ThreadEnv;
JniLocalHandle clazz = env.GetObjectClass(handle);
Wrapper wrapper = GetWrapper(env, clazz);
var ret = wrapper.Constructor.Invoke(new object[] { env }) as JavaException;
ret.Init(env, handle);
return(ret);
}
public static T[] WrapJavaArrayObject <T>(JniLocalHandle handle)
{
if (JniHandle.IsNull(handle))
{
return(null);
}
JNIEnv env = JNIEnv.ThreadEnv;
var length = env.GetArrayLength(handle);
T[] ret = new T[length];
Type type = typeof(T).GetElementType();
if (type.IsPrimitive)
{
if (type == typeof(int) || type == typeof(uint))
{
env.GetIntArrayRegion(handle, 0, length, ret as int[]);
return(ret);
}
if (type == typeof(long) || type == typeof(ulong))
{
env.GetLongArrayRegion(handle, 0, length, ret as long[]);
return(ret);
}
if (type == typeof(bool))
{
env.GetBooleanArrayRegion(handle, 0, length, ret as bool[]);
return(ret);
}
if (type == typeof(double))
{
env.GetDoubleArrayRegion(handle, 0, length, ret as double[]);
return(ret);
}
if (type == typeof(byte) || type == typeof(sbyte))
{
env.GetByteArrayRegion(handle, 0, length, ret as byte[]);
return(ret);
}
if (type == typeof(char))
{
env.GetCharArrayRegion(handle, 0, length, ret as char[]);
return(ret);
}
if (type == typeof(short) || type == typeof(ushort))
{
env.GetShortArrayRegion(handle, 0, length, ret as short[]);
return(ret);
}
if (type == typeof(float))
{
env.GetFloatArrayRegion(handle, 0, length, ret as float[]);
return(ret);
}
}
if (type.IsArray)
{
MethodInfo method = mWrapJavaArrayObject.MakeGenericMethod(type.GetElementType());
for (int i = 0; i < length; i++)
{
ret[i] = (T)method.Invoke(null, new object[] { env.GetObjectArrayElement(handle, i) });
}
}
else if (type.IsInterface)
{
MethodInfo method = mWrapIJavaObject.MakeGenericMethod(type);
for (int i = 0; i < length; i++)
{
ret[i] = (T)method.Invoke(null, new object[] { env.GetObjectArrayElement(handle, i) });
}
}
else if (type.IsSubclassOf(typeof(JavaException)))
{
JavaException[] exceptions = ret as JavaException[];
for (int i = 0; i < length; i++)
{
exceptions[i] = WrapJavaException(env.GetObjectArrayElement(handle, i));
}
}
else if (type.IsSubclassOf(typeof(JavaObject)))
{
JavaObject[] objects = ret as JavaObject[];
for (int i = 0; i < length; i++)
{
objects[i] = WrapJavaObject(env.GetObjectArrayElement(handle, i));
}
}
else
{
throw new InvalidOperationException("Trying to convert unknown type.");
}
return(ret);
}