private static JavaType TypeByJniName(JniWrapper vm, string name) { if (String.IsNullOrEmpty(name)) { throw new ArgumentNullException("name"); } switch (name[0]) { case 'Z': return(PrimitiveType.Boolean(vm)); case 'B': return(PrimitiveType.Byte(vm)); case 'C': return(PrimitiveType.Char(vm)); case 'S': return(PrimitiveType.Short(vm)); case 'I': return(PrimitiveType.Int(vm)); case 'J': return(PrimitiveType.Long(vm)); case 'F': return(PrimitiveType.Float(vm)); case 'D': return(PrimitiveType.Double(vm)); case 'L': return(new JavaClass(vm, name.TrimStart('L').TrimEnd(';').Replace('/', '.'))); case '[': return(new ArrayType(TypeByJniName(vm, name.Substring(1)))); default: throw new InvalidOperationException("Can't decipher this JNI type name: " + name); } }
public static JavaType FromReflectedType(JniWrapper vm, IntPtr reflectedType) { string name = new JClassClass(vm).GetName(reflectedType); if (name.StartsWith("[")) { return(TypeByJniName(vm, name)); } PrimitiveType primitiveType = PrimitiveType.FromString(vm, name); if (primitiveType != null) { return(primitiveType); } return(new JavaClass(vm, IntPtr.Zero, reflectedType, name)); }
public JavaObject(JniWrapper vm, IntPtr objectPointer, JavaClass javaClass) { _vm = vm; _objectPointer = objectPointer; _methodClass = new JMethodClass(_vm); _classClass = new JClassClass(_vm); _objectClass = new JObjectClass(_vm); if (javaClass == null && _objectPointer != IntPtr.Zero) { _class = new JavaClass(vm, jniClass: vm.GetObjectClass(_objectPointer), reflectedClass: _objectClass.GetClass(_objectPointer), name: null); } else { _class = javaClass; } }
public static ParameterInfo[] GetParameterInfo(JniWrapper vm, object[] args) { ParameterInfo[] ret = new ParameterInfo[args.Length]; for (int i = 0; i < args.Length; i++) { if (args[i] == null) { ret[i] = new ParameterInfo(new JValue(IntPtr.Zero), new NullType()); } else { JavaObjectFactory objectFactory = GetJavaType(vm, args[i].GetType(), args[i]); ret[i] = new ParameterInfo(objectFactory.Create(args[i]), objectFactory.JavaType); } } return(ret); }
public static JavaObjectFactory Array(JniWrapper vm, Type dotNetType, Array prototype) { object innerPrototype = null; if (prototype != null && prototype.Length > 0) { innerPrototype = prototype.GetValue(0); } JavaObjectFactory innerFactory = GetJavaType(vm, dotNetType.GetElementType(), innerPrototype); ArrayType javaArrayType = new ArrayType(innerFactory.JavaType); return(new JavaObjectFactory(o => { Array asArray = (Array)o; PrimitiveType asPrimitive = javaArrayType.MemberType as PrimitiveType; if (asPrimitive != null) { switch (asPrimitive.Kind) { case PrimitiveTypeKind.Boolean: return vm.NewBooleanArray((bool[])o); case PrimitiveTypeKind.Byte: return vm.NewByteArray((byte[])o); case PrimitiveTypeKind.Char: return vm.NewCharArray((char[])o); case PrimitiveTypeKind.Double: return vm.NewDoubleArray((double[])o); case PrimitiveTypeKind.Float: return vm.NewFloatArray((float[])o); case PrimitiveTypeKind.Int: return vm.NewIntArray((int[])o); case PrimitiveTypeKind.Long: return vm.NewLongArray((long[])o); case PrimitiveTypeKind.Short: return vm.NewShortArray((short[])o); default: throw new InvalidOperationException("Unknown primitive kind: " + asPrimitive.Kind); } } else { IntPtr[] elements = asArray.Cast <object>().Select(innerFactory._factory).Select(v => v.ToIntPtr()).ToArray(); return vm.NewArray(vm.FindClass(innerFactory.JavaType.JniClassName), elements); } }, javaArrayType)); }
public JValue Value(JniWrapper vm, bool box) { if (!box) { return(_value); } else { ArrayType asArray; if ((asArray = _type as ArrayType) != null) { JavaArray arrayObject = new JavaArray(vm, _value.ToIntPtr(), asArray); return(arrayObject.Box()); } else { PrimitiveType primitiveType = (PrimitiveType)_type; return(primitiveType.GetBoxClass().Box(_value, primitiveType)); } } }
internal JavaClass(JniWrapper vm, IntPtr jniClass, IntPtr reflectedClass, string name) { _vm = vm; _classClass = new JClassClass(vm); _methodClass = new JMethodClass(vm); _fieldClass = new JFieldClass(vm); _constructorClass = new JConstructorClass(vm); _classLoaderClass = new JClassLoaderClass(vm); _jniClass = jniClass; _reflectedClass = reflectedClass; if (_reflectedClass == IntPtr.Zero) { if (name == null) { throw new ArgumentNullException("I can't infer the name from just the JNI class (I should be able to, but I have no idea how)."); } _reflectedClass = _classClass.ForName(name.Replace('/', '.'), true, _classLoaderClass.GetSystemClassLoader()); if (_reflectedClass == IntPtr.Zero) { ThrowClassNotFoundException(name); } } if (name == null) { name = _classClass.GetName(_reflectedClass); } if (_jniClass == IntPtr.Zero) { _jniClass = vm.FindClass(name.Replace('.', '/')); if (_jniClass == IntPtr.Zero) { ThrowClassNotFoundException(name); } } _name = name.Replace('/', '.'); _allMethods = _classClass.GetMethods(_reflectedClass).ToList().AsReadOnly(); _allConstructors = _classClass.GetConstructors(_reflectedClass).ToList().AsReadOnly(); }
public static PrimitiveType FromString(JniWrapper vm, string name) { switch (name) { case "byte": return(new PrimitiveType(vm, PrimitiveTypeKind.Byte)); case "short": return(new PrimitiveType(vm, PrimitiveTypeKind.Short)); case "int": return(new PrimitiveType(vm, PrimitiveTypeKind.Int)); case "long": return(new PrimitiveType(vm, PrimitiveTypeKind.Long)); case "char": return(new PrimitiveType(vm, PrimitiveTypeKind.Char)); case "float": return(new PrimitiveType(vm, PrimitiveTypeKind.Float)); case "double": return(new PrimitiveType(vm, PrimitiveTypeKind.Double)); case "boolean": return(new PrimitiveType(vm, PrimitiveTypeKind.Boolean)); default: return(null); } }
public static JavaObjectFactory Char(JniWrapper vm) { return(new JavaObjectFactory(o => new JValue((char)o), PrimitiveType.Char(vm))); }
public static JavaObjectFactory Double(JniWrapper vm) { return(new JavaObjectFactory(o => new JValue((double)o), PrimitiveType.Double(vm))); }
public static JavaObjectFactory Float(JniWrapper vm) { return(new JavaObjectFactory(o => new JValue((float)o), PrimitiveType.Float(vm))); }
public static JavaObjectFactory Long(JniWrapper vm) { return(new JavaObjectFactory(o => new JValue((long)o), PrimitiveType.Long(vm))); }
public static PrimitiveType Boolean(JniWrapper vm) { return(new PrimitiveType(vm, PrimitiveTypeKind.Boolean)); }
public static PrimitiveType Int(JniWrapper vm) { return(new PrimitiveType(vm, PrimitiveTypeKind.Int)); }
public static JavaObjectFactory Array(JniWrapper vm, ArrayType arrayType) { return(new JavaObjectFactory(o => new JValue(((JavaArray)o).ArrayPointer), arrayType)); }
public static PrimitiveType Long(JniWrapper vm) { return(new PrimitiveType(vm, PrimitiveTypeKind.Long)); }
public static PrimitiveType Char(JniWrapper vm) { return(new PrimitiveType(vm, PrimitiveTypeKind.Char)); }
private DarkJava(string jvmDllPath, bool attemptVmReuse, IEnumerable <JavaOption> options) { _jniWrapper = new JniWrapper(jvmDllPath: jvmDllPath, attemptVmReuse: attemptVmReuse, options: options ?? Enumerable.Empty <JavaOption>()); _defaultPackage = new JavaPackage(_jniWrapper, ""); }
public static PrimitiveType Float(JniWrapper vm) { return(new PrimitiveType(vm, PrimitiveTypeKind.Float)); }
/// <summary> /// Constructs the wrapper given the fully qualified class name. /// </summary> /// <param name="vm"></param> /// <param name="name"></param> public JavaClass(JniWrapper vm, string name) : this(vm, jniClass : IntPtr.Zero, reflectedClass : IntPtr.Zero, name : name) { }
public JavaPackage(JniWrapper vm, string name) { _vm = vm; _name = name.Replace('.', '/'); }
public static JavaObjectFactory Boolean(JniWrapper vm) { return(new JavaObjectFactory(o => new JValue((bool)o), PrimitiveType.Boolean(vm))); }
public static JavaObjectFactory Object(JniWrapper vm, JavaClass javaClass) { return(new JavaObjectFactory(o => new JValue(((JavaObject)o).Pointer), javaClass)); }
public static PrimitiveType Short(JniWrapper vm) { return(new PrimitiveType(vm, PrimitiveTypeKind.Short)); }
private static JavaObjectFactory GetJavaType(JniWrapper vm, Type dotNetType, object prototype) { if (dotNetType.IsArray) { return(JavaObjectFactory.Array(vm, dotNetType, (Array)prototype)); } else if (dotNetType.IsAssignableFrom(typeof(string))) { return(JavaObjectFactory.String(vm)); } else if (dotNetType.IsAssignableFrom(typeof(byte))) { return(JavaObjectFactory.Byte(vm)); } else if (dotNetType.IsAssignableFrom(typeof(short))) { return(JavaObjectFactory.Short(vm)); } else if (dotNetType.IsAssignableFrom(typeof(int))) { return(JavaObjectFactory.Int(vm)); } else if (dotNetType.IsAssignableFrom(typeof(long))) { return(JavaObjectFactory.Long(vm)); } else if (dotNetType.IsAssignableFrom(typeof(float))) { return(JavaObjectFactory.Float(vm)); } else if (dotNetType.IsAssignableFrom(typeof(double))) { return(JavaObjectFactory.Double(vm)); } else if (dotNetType.IsAssignableFrom(typeof(char))) { return(JavaObjectFactory.Char(vm)); } else if (dotNetType.IsAssignableFrom(typeof(bool))) { return(JavaObjectFactory.Boolean(vm)); } else if (dotNetType.IsAssignableFrom(typeof(JavaObject))) { if (prototype == null) { throw new InvalidOperationException("Can't infer the type of the Java object without an instance."); } return(JavaObjectFactory.Object(vm, ((JavaObject)prototype).Class)); } else if (dotNetType.IsAssignableFrom(typeof(JavaArray))) { if (prototype == null) { throw new InvalidOperationException("Can't infer the type of the Java array without an instance."); } return(JavaObjectFactory.Array(vm, ((JavaArray)prototype).ArrayType)); } else { throw new InvalidOperationException("Can't infer the Java type of " + dotNetType); } }
public static JavaObjectFactory Byte(JniWrapper vm) { return(new JavaObjectFactory(o => new JValue((byte)o), PrimitiveType.Byte(vm))); }
public static JavaObjectFactory Short(JniWrapper vm) { return(new JavaObjectFactory(o => new JValue((short)o), PrimitiveType.Short(vm))); }
public static PrimitiveType Double(JniWrapper vm) { return(new PrimitiveType(vm, PrimitiveTypeKind.Double)); }
public JavaArray(JniWrapper vm, IntPtr arrayPtr, ArrayType arrayType) { _vm = vm; _arrayPtr = arrayPtr; _arrayType = arrayType; }
public static JavaObjectFactory String(JniWrapper vm) { return(new JavaObjectFactory(o => vm.NewString((string)o), new JavaClass(vm, "java/lang/String"))); }