static void AssertGetJniTypeInfoForJniTypeReference(string jniTypeReference, string jniTypeName, bool typeIsKeyword = false, int arrayRank = 0)
{
var sig = JniTypeSignature.Parse(jniTypeReference);
Assert.AreEqual(jniTypeName, sig.SimpleReference, "JniTypeName for: " + jniTypeReference);
Assert.AreEqual(arrayRank, sig.ArrayRank, "ArrayRank for: " + jniTypeReference);
}
public override DynamicMetaObject BindConvert(ConvertBinder binder)
{
var vm = JniEnvironment.Runtime;
if (binder.Type == typeof(Type))
{
var sig = JniTypeSignature.Parse(info.JniClassName);
var type = vm.TypeManager.GetType(sig);
var typeE = Expression.Convert(Expression.Constant(type), binder.Type);
return(new DynamicMetaObject(typeE, BindingRestrictions.GetTypeRestriction(typeE, binder.Type), type));
}
object value;
try {
var r = ConversionTarget;
value = vm.ValueManager.GetValue(ref r, JniObjectReferenceOptions.Copy, binder.Type);
} catch {
return(binder.FallbackConvert(this));
}
var valueE = Expression.Convert(Expression.Constant(value), binder.Type);
return(new DynamicMetaObject(valueE, BindingRestrictions.GetTypeRestriction(valueE, binder.Type), value));
}
public void Sanity()
{
var a = new JniTypeSignature("java/lang/Object", arrayRank: 2);
Assert.AreEqual("java/lang/Object", a.SimpleReference);
Assert.AreEqual(2, a.ArrayRank);
Assert.AreEqual("[[Ljava/lang/Object;", a.Name);
Assert.AreEqual("[[Ljava/lang/Object;", a.QualifiedReference);
}
public new void GetType()
{
var manager = JniRuntime.CurrentRuntime.TypeManager;
Func <string, Type> GetType = s => {
var sig = JniTypeSignature.Parse(s);
return(manager.GetType(sig));
};
Assert.Throws <ArgumentNullException> (() => GetType(null));
Assert.Throws <ArgumentException> (() => GetType("java.lang.String"));
Assert.Throws <ArgumentException> (() => GetType("Ljava/lang/String;I"));
Assert.Throws <ArgumentException> (() => GetType("ILjava/lang/String;"));
Assert.AreEqual(typeof(void), GetType("V"));
Assert.AreEqual(typeof(bool), GetType("Z"));
Assert.AreEqual(typeof(char), GetType("C"));
Assert.AreEqual(typeof(sbyte), GetType("B"));
Assert.AreEqual(typeof(short), GetType("S"));
Assert.AreEqual(typeof(int), GetType("I"));
Assert.AreEqual(typeof(long), GetType("J"));
Assert.AreEqual(typeof(float), GetType("F"));
Assert.AreEqual(typeof(double), GetType("D"));
Assert.AreEqual(typeof(string), GetType("java/lang/String"));
Assert.AreEqual(null, GetType("com/example/does/not/exist"));
Assert.AreEqual(null, GetType("Lcom/example/does/not/exist;"));
Assert.AreEqual(null, GetType("[Lcom/example/does/not/exist;"));
Assert.AreEqual(typeof(JavaPrimitiveArray <bool>), GetType("[Z"));
Assert.AreEqual(typeof(JavaPrimitiveArray <char>), GetType("[C"));
Assert.AreEqual(typeof(JavaPrimitiveArray <sbyte>), GetType("[B"));
Assert.AreEqual(typeof(JavaPrimitiveArray <short>), GetType("[S"));
Assert.AreEqual(typeof(JavaPrimitiveArray <int>), GetType("[I"));
Assert.AreEqual(typeof(JavaPrimitiveArray <long>), GetType("[J"));
Assert.AreEqual(typeof(JavaPrimitiveArray <float>), GetType("[F"));
Assert.AreEqual(typeof(JavaPrimitiveArray <double>), GetType("[D"));
Assert.AreEqual(typeof(JavaObjectArray <string>), GetType("[Ljava/lang/String;"));
Assert.AreEqual(typeof(JavaObjectArray <JavaPrimitiveArray <bool> >), GetType("[[Z"));
Assert.AreEqual(typeof(JavaObjectArray <JavaPrimitiveArray <char> >), GetType("[[C"));
Assert.AreEqual(typeof(JavaObjectArray <JavaPrimitiveArray <sbyte> >), GetType("[[B"));
Assert.AreEqual(typeof(JavaObjectArray <JavaPrimitiveArray <short> >), GetType("[[S"));
Assert.AreEqual(typeof(JavaObjectArray <JavaPrimitiveArray <int> >), GetType("[[I"));
Assert.AreEqual(typeof(JavaObjectArray <JavaPrimitiveArray <long> >), GetType("[[J"));
Assert.AreEqual(typeof(JavaObjectArray <JavaPrimitiveArray <float> >), GetType("[[F"));
Assert.AreEqual(typeof(JavaObjectArray <JavaPrimitiveArray <double> >), GetType("[[D"));
Assert.AreEqual(typeof(JavaObjectArray <JavaObjectArray <string> >), GetType("[[Ljava/lang/String;"));
// Yes, these look weird...
// Assume: class II {}
Assert.AreEqual(null, GetType("II"));
// Assume: package Ljava.lang; class String {}
Assert.AreEqual(null, GetType("Ljava/lang/String"));
}
Dictionary <string, List <JavaFieldInfo> > LookupFields()
{
if (Members == null)
{
return(null);
}
lock (Members) {
if (this.fields != null || Disposed)
{
return(this.fields);
}
this.fields = new Dictionary <string, List <JavaFieldInfo> > ();
var fields = JniEnvironment.InstanceMethods.CallObjectMethod(Members.JniPeerType.PeerReference, Class_getFields);
try {
int len = JniEnvironment.Arrays.GetArrayLength(fields);
for (int i = 0; i < len; ++i)
{
var field = JniEnvironment.Arrays.GetObjectArrayElement(fields, i);
var n_name = JniEnvironment.InstanceMethods.CallObjectMethod(field, Field_getName);
var name = JniEnvironment.Strings.ToString(ref n_name, JniObjectReferenceOptions.CopyAndDispose);
var isStatic = IsStatic(field);
List <JavaFieldInfo> overloads;
if (!Fields.TryGetValue(name, out overloads))
{
Fields.Add(name, overloads = new List <JavaFieldInfo> ());
}
var n_type = JniEnvironment.InstanceMethods.CallObjectMethod(field, Field_getType);
using (var type = new JniType(ref n_type, JniObjectReferenceOptions.CopyAndDispose)) {
var sig = JniTypeSignature.Parse(type.Name);
overloads.Add(new JavaFieldInfo(Members, name + "." + sig.QualifiedReference, isStatic));
}
JniObjectReference.Dispose(ref field);
}
} finally {
JniObjectReference.Dispose(ref fields);
}
return(this.fields);
}
}
public void Parse()
{
Assert.Throws <ArgumentNullException> (() => JniTypeSignature.Parse((string)null));
Assert.Throws <ArgumentException> (() => JniTypeSignature.Parse("java.lang.String"));
Assert.Throws <ArgumentException> (() => JniTypeSignature.Parse("Ljava/lang/String;I"));
Assert.Throws <ArgumentException> (() => JniTypeSignature.Parse("ILjava/lang/String;"));
AssertGetJniTypeInfoForJniTypeReference("java/lang/String", "java/lang/String");
AssertGetJniTypeInfoForJniTypeReference("Ljava/lang/String;", "java/lang/String");
AssertGetJniTypeInfoForJniTypeReference("[I", "I", true, 1);
AssertGetJniTypeInfoForJniTypeReference("[[I", "I", true, 2);
AssertGetJniTypeInfoForJniTypeReference("[Ljava/lang/Object;", "java/lang/Object", false, 1);
// Yes, these look _really_ weird...
// Assume: class II {}
AssertGetJniTypeInfoForJniTypeReference("II", "II");
// Assume: package Ljava.lang; class String {}
AssertGetJniTypeInfoForJniTypeReference("Ljava/lang/String", "Ljava/lang/String");
}
public void LookupArguments()
{
if (arguments != null)
{
return;
}
var vm = JniEnvironment.Runtime;
var sb = new StringBuilder();
var mgr = vm.TypeManager;
if (!IsConstructor)
{
sb.Append(Name).Append(".");
}
sb.Append("(");
var parameters = IsConstructor
? JavaClassInfo.GetConstructorParameters(PeerReference)
: JavaClassInfo.GetMethodParameters(PeerReference);
try {
int len = JniEnvironment.Arrays.GetArrayLength(parameters);
arguments = new List <JniObjectReference> (len);
for (int i = 0; i < len; ++i)
{
var p = JniEnvironment.Arrays.GetObjectArrayElement(parameters, i);
try {
var sig = JniTypeSignature.Parse(JniEnvironment.Types.GetJniTypeNameFromClass(p));
sb.Append(sig.QualifiedReference);
arguments.Add(p.NewGlobalRef());
} finally {
JniObjectReference.Dispose(ref p);
}
}
} finally {
JniObjectReference.Dispose(ref parameters);
}
sb.Append(")").Append(JniReturnType);
JniSignature = sb.ToString();
}
public void GetTypeSignature()
{
var jvm = JniRuntime.CurrentRuntime;
Func <string, Type> GetTypeForSimpleReference = s => {
var sig = JniTypeSignature.Parse(s);
return(jvm.TypeManager.GetType(sig));
};
Assert.Throws <ArgumentNullException> (() => GetTypeForSimpleReference(null));
Assert.Throws <ArgumentException> (() => GetTypeForSimpleReference("foo.bar"));
Assert.AreEqual(typeof(void), GetTypeForSimpleReference("V"));
Assert.AreEqual(typeof(bool), GetTypeForSimpleReference("Z"));
Assert.AreEqual(typeof(char), GetTypeForSimpleReference("C"));
Assert.AreEqual(typeof(sbyte), GetTypeForSimpleReference("B"));
Assert.AreEqual(typeof(short), GetTypeForSimpleReference("S"));
Assert.AreEqual(typeof(int), GetTypeForSimpleReference("I"));
Assert.AreEqual(typeof(long), GetTypeForSimpleReference("J"));
Assert.AreEqual(typeof(float), GetTypeForSimpleReference("F"));
Assert.AreEqual(typeof(double), GetTypeForSimpleReference("D"));
Assert.AreEqual(typeof(string), GetTypeForSimpleReference("java/lang/String"));
Assert.AreEqual(null, GetTypeForSimpleReference("com/example/does/not/exist"));
}
public void QualifiedReference()
{
var info = new JniTypeSignature("java/lang/String");
Assert.AreEqual("Ljava/lang/String;", info.QualifiedReference);
Assert.AreEqual("java/lang/String", info.SimpleReference);
Assert.AreEqual("java/lang/String", info.Name);
info = new JniTypeSignature("java/lang/String", arrayRank: 1);
Assert.AreEqual("java/lang/String", info.SimpleReference);
Assert.AreEqual("[Ljava/lang/String;", info.QualifiedReference);
Assert.AreEqual("[Ljava/lang/String;", info.Name);
info = new JniTypeSignature("B", keyword: true);
Assert.AreEqual("B", info.Name);
Assert.AreEqual("B", info.QualifiedReference);
Assert.AreEqual("B", info.SimpleReference);
info = new JniTypeSignature("B", arrayRank: 2, keyword: true);
Assert.AreEqual("[[B", info.Name);
Assert.AreEqual("[[B", info.QualifiedReference);
Assert.AreEqual("B", info.SimpleReference);
}
