diff --git a/tools/generator/CodeGenerator.cs b/tools/generator/CodeGenerator.cs index 875eb70e9..b515de661 100644 --- a/tools/generator/CodeGenerator.cs +++ b/tools/generator/CodeGenerator.cs @@ -323,16 +323,19 @@ static void Run (CodeGeneratorOptions options, DirectoryAssemblyResolver resolve if (api_versions_xml != null) ApiVersionsSupport.AssignApiLevels (gens, api_versions_xml); - foreach (GenBase gen in gens) + foreach (var gen in gens) + gen.FixupCovariantReturnTypes (); + + foreach (var gen in gens) gen.FillProperties (); foreach (var gen in gens) gen.UpdateEnums (opt); - foreach (GenBase gen in gens) + foreach (var gen in gens) gen.FixupMethodOverrides (); - foreach (GenBase gen in gens) + foreach (var gen in gens) gen.FixupExplicitImplementation (); GenerateAnnotationAttributes (gens, annotations_zips); diff --git a/tools/generator/GenBase.cs b/tools/generator/GenBase.cs index bb026e421..0573f5d3e 100644 --- a/tools/generator/GenBase.cs +++ b/tools/generator/GenBase.cs @@ -727,6 +727,26 @@ public void StripNonBindables () n.StripNonBindables (); } + public void FixupCovariantReturnTypes() + { + //Fix up Java covariant return types, C# return type must match the base return type + foreach (Method m in methods) { + var baseCovariantMethod = BaseGen?.methods.FirstOrDefault (bm => bm.IsCovariantOverride (m)); + if (baseCovariantMethod == null) { + baseCovariantMethod = ifaces.OfType () + .SelectMany (i => i.methods) + .FirstOrDefault (im => im.IsCovariantOverride (m)); + } + if (baseCovariantMethod != null && m.ManagedReturn == null) { + m.RetVal.FullName = baseCovariantMethod.ReturnType; + m.RetVal.ToNativeOverride = baseCovariantMethod.RetVal.ToNative; + } + } + + foreach (var nt in NestedTypes) + nt.FixupCovariantReturnTypes (); + } + public void FillProperties () { if (property_filled) diff --git a/tools/generator/Method.cs b/tools/generator/Method.cs index 3469140ec..b269a65f4 100644 --- a/tools/generator/Method.cs +++ b/tools/generator/Method.cs @@ -262,7 +262,7 @@ protected Method (GenBase declaringType, IMethodBaseSupport support) internal void FillReturnType () { - retval = new ReturnValue (this, Return, ManagedReturn, IsReturnEnumified); + retval = new ReturnValue (Return, ManagedReturn, IsReturnEnumified); } public bool GenerateDispatchingSetter { get; protected set; } @@ -456,7 +456,22 @@ string GetDelegateType () } return delegate_type; } - + + public bool IsCovariantOverride (Method overriddenMethod) + { + //A method with a covariant return type would have the following to be true: + // 1) Neither is generic + // 2) JavaName is the same + // 3) retval.JavaName is *different* + // 4) Same number of parameters + // 5) JavaSignature for parameters is the same + return !IsGeneric && !overriddenMethod.IsGeneric && + JavaName == overriddenMethod.JavaName && + retval.JavaName != overriddenMethod.retval.JavaName && + Parameters.Count == overriddenMethod.Parameters.Count && + Parameters.JavaSignature == overriddenMethod.Parameters.JavaSignature; + } + // it used to be private though... internal string AdjustedName { get { return IsReturnCharSequence ? Name + "Formatted" : Name; } diff --git a/tools/generator/ReturnValue.cs b/tools/generator/ReturnValue.cs index 1e6730a0c..88cce299c 100644 --- a/tools/generator/ReturnValue.cs +++ b/tools/generator/ReturnValue.cs @@ -14,8 +14,9 @@ public class ReturnValue { string managed_type; string raw_type; bool is_enumified; + Func to_native; - public ReturnValue (Method owner, string java_type, string managed_type, bool isEnumified) + public ReturnValue (string java_type, string managed_type, bool isEnumified) { this.raw_type = this.java_type = java_type; this.managed_type = managed_type; @@ -36,12 +37,8 @@ public string DefaultValue { } public string FullName { - get { - if (!String.IsNullOrEmpty (managed_type)) - return managed_type; - return sym.FullName; - //return sym is GenBase && !String.IsNullOrEmpty ((sym as GenBase).Marshaler) ? (sym as GenBase).Marshaler : sym.FullName; - } + get { return !String.IsNullOrEmpty (managed_type) ? managed_type : sym.FullName; } + set { managed_type = value; } } public void SetGeneratedEnumType (string enumType) @@ -89,6 +86,12 @@ public string RawJavaType { get { return raw_type; } } + public Func ToNativeOverride + { + get { return to_native; } + set { to_native = value; } + } + public string FromNative (CodeGenerationOptions opt, string var_name, bool owned) { if (!string.IsNullOrEmpty (managed_type) && (sym is ClassGen || sym is InterfaceGen)) { @@ -100,6 +103,9 @@ public string FromNative (CodeGenerationOptions opt, string var_name, bool owned public string ToNative (CodeGenerationOptions opt, string var_name) { + if (to_native != null) + return to_native (opt, var_name); + return ((sym is GenericTypeParameter) || (sym is GenericSymbol)) ? String.Format ("JNIEnv.ToLocalJniHandle ({0})", var_name) : sym.ToNative (opt, var_name); } diff --git a/tools/generator/Tests/CovariantReturnTypes.cs b/tools/generator/Tests/CovariantReturnTypes.cs new file mode 100644 index 000000000..5def337d9 --- /dev/null +++ b/tools/generator/Tests/CovariantReturnTypes.cs @@ -0,0 +1,20 @@ +using System; +using NUnit.Framework; + +namespace generatortests +{ + [TestFixture] + public class CovariantReturnTypes : BaseGeneratorTest + { + [Test] + public void GeneratedOK () + { + AllowWarnings = true; + RunAllTargets ( + outputRelativePath: "CovariantReturnTypes", + apiDescriptionFile: "expected/CovariantReturnTypes/CovariantReturnTypes.xml", + expectedRelativePath: "CovariantReturnTypes"); + } + } +} + diff --git a/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantClass.cs b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantClass.cs new file mode 100644 index 000000000..6899e74ed --- /dev/null +++ b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantClass.cs @@ -0,0 +1,62 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; +using Java.Interop; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantClass']" + [global::Android.Runtime.Register ("covariant/returntypes/CovariantClass", DoNotGenerateAcw=true)] + public partial class CovariantClass : global::Java.Lang.Object { + + internal new static readonly JniPeerMembers _members = new JniPeerMembers ("covariant/returntypes/CovariantClass", typeof (CovariantClass)); + internal static new IntPtr class_ref { + get { + return _members.JniPeerType.PeerReference.Handle; + } + } + + public override global::Java.Interop.JniPeerMembers JniPeerMembers { + get { return _members; } + } + + protected override IntPtr ThresholdClass { + get { return _members.JniPeerType.PeerReference.Handle; } + } + + protected override global::System.Type ThresholdType { + get { return _members.ManagedPeerType; } + } + + protected CovariantClass (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.CovariantClass __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantClass']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/Object;", "GetSomeMethodHandler")] + public virtual unsafe global::Java.Lang.Object SomeMethod () + { + const string __id = "someMethod.()Ljava/lang/Object;"; + try { + var __rm = _members.InstanceMethods.InvokeVirtualObjectMethod (__id, this, null); + return global::Java.Lang.Object.GetObject (__rm.Handle, JniHandleOwnership.TransferLocalRef); + } finally { + } + } + + } +} diff --git a/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantInterfaceImplementation.cs b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantInterfaceImplementation.cs new file mode 100644 index 000000000..ada83a26c --- /dev/null +++ b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantInterfaceImplementation.cs @@ -0,0 +1,80 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; +using Java.Interop; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantInterfaceImplementation']" + [global::Android.Runtime.Register ("covariant/returntypes/CovariantInterfaceImplementation", DoNotGenerateAcw=true)] + public partial class CovariantInterfaceImplementation : global::Java.Lang.Object, global::Covariant.Returntypes.ICovariantInterface { + + internal new static readonly JniPeerMembers _members = new JniPeerMembers ("covariant/returntypes/CovariantInterfaceImplementation", typeof (CovariantInterfaceImplementation)); + internal static new IntPtr class_ref { + get { + return _members.JniPeerType.PeerReference.Handle; + } + } + + public override global::Java.Interop.JniPeerMembers JniPeerMembers { + get { return _members; } + } + + protected override IntPtr ThresholdClass { + get { return _members.JniPeerType.PeerReference.Handle; } + } + + protected override global::System.Type ThresholdType { + get { return _members.ManagedPeerType; } + } + + protected CovariantInterfaceImplementation (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantInterfaceImplementation']/constructor[@name='CovariantInterfaceImplementation' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe CovariantInterfaceImplementation () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + const string __id = "()V"; + + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + var __r = _members.InstanceMethods.StartCreateInstance (__id, ((object) this).GetType (), null); + SetHandle (__r.Handle, JniHandleOwnership.TransferLocalRef); + _members.InstanceMethods.FinishCreateInstance (__id, this, null); + } finally { + } + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.CovariantInterfaceImplementation __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantInterfaceImplementation']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/String;", "GetSomeMethodHandler")] + public virtual unsafe global::Java.Lang.Object SomeMethod () + { + const string __id = "someMethod.()Ljava/lang/String;"; + try { + var __rm = _members.InstanceMethods.InvokeVirtualObjectMethod (__id, this, null); + return JNIEnv.GetString (__rm.Handle, JniHandleOwnership.TransferLocalRef); + } finally { + } + } + + } +} diff --git a/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertyClass.cs b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertyClass.cs new file mode 100644 index 000000000..de2efa667 --- /dev/null +++ b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertyClass.cs @@ -0,0 +1,63 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; +using Java.Interop; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertyClass']" + [global::Android.Runtime.Register ("covariant/returntypes/CovariantPropertyClass", DoNotGenerateAcw=true)] + public partial class CovariantPropertyClass : global::Java.Lang.Object { + + internal new static readonly JniPeerMembers _members = new JniPeerMembers ("covariant/returntypes/CovariantPropertyClass", typeof (CovariantPropertyClass)); + internal static new IntPtr class_ref { + get { + return _members.JniPeerType.PeerReference.Handle; + } + } + + public override global::Java.Interop.JniPeerMembers JniPeerMembers { + get { return _members; } + } + + protected override IntPtr ThresholdClass { + get { return _members.JniPeerType.PeerReference.Handle; } + } + + protected override global::System.Type ThresholdType { + get { return _members.ManagedPeerType; } + } + + protected CovariantPropertyClass (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + static Delegate cb_getObject; +#pragma warning disable 0169 + static Delegate GetGetObjectHandler () + { + if (cb_getObject == null) + cb_getObject = JNINativeWrapper.CreateDelegate ((Func) n_GetObject); + return cb_getObject; + } + + static IntPtr n_GetObject (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.CovariantPropertyClass __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.Object); + } +#pragma warning restore 0169 + + public virtual unsafe global::Java.Lang.Object Object { + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertyClass']/method[@name='getObject' and count(parameter)=0]" + [Register ("getObject", "()Ljava/lang/Object;", "GetGetObjectHandler")] + get { + const string __id = "getObject.()Ljava/lang/Object;"; + try { + var __rm = _members.InstanceMethods.InvokeVirtualObjectMethod (__id, this, null); + return global::Java.Lang.Object.GetObject (__rm.Handle, JniHandleOwnership.TransferLocalRef); + } finally { + } + } + } + + } +} diff --git a/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertyImplementation.cs b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertyImplementation.cs new file mode 100644 index 000000000..d27b35e35 --- /dev/null +++ b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertyImplementation.cs @@ -0,0 +1,81 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; +using Java.Interop; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertyImplementation']" + [global::Android.Runtime.Register ("covariant/returntypes/CovariantPropertyImplementation", DoNotGenerateAcw=true)] + public partial class CovariantPropertyImplementation : global::Java.Lang.Object, global::Covariant.Returntypes.ICovariantPropertyInterface { + + internal new static readonly JniPeerMembers _members = new JniPeerMembers ("covariant/returntypes/CovariantPropertyImplementation", typeof (CovariantPropertyImplementation)); + internal static new IntPtr class_ref { + get { + return _members.JniPeerType.PeerReference.Handle; + } + } + + public override global::Java.Interop.JniPeerMembers JniPeerMembers { + get { return _members; } + } + + protected override IntPtr ThresholdClass { + get { return _members.JniPeerType.PeerReference.Handle; } + } + + protected override global::System.Type ThresholdType { + get { return _members.ManagedPeerType; } + } + + protected CovariantPropertyImplementation (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertyImplementation']/constructor[@name='CovariantPropertyImplementation' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe CovariantPropertyImplementation () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + const string __id = "()V"; + + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + var __r = _members.InstanceMethods.StartCreateInstance (__id, ((object) this).GetType (), null); + SetHandle (__r.Handle, JniHandleOwnership.TransferLocalRef); + _members.InstanceMethods.FinishCreateInstance (__id, this, null); + } finally { + } + } + + static Delegate cb_getObject; +#pragma warning disable 0169 + static Delegate GetGetObjectHandler () + { + if (cb_getObject == null) + cb_getObject = JNINativeWrapper.CreateDelegate ((Func) n_GetObject); + return cb_getObject; + } + + static IntPtr n_GetObject (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.CovariantPropertyImplementation __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.Object); + } +#pragma warning restore 0169 + + public virtual unsafe global::Java.Lang.Object Object { + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertyImplementation']/method[@name='getObject' and count(parameter)=0]" + [Register ("getObject", "()Ljava/lang/String;", "GetGetObjectHandler")] + get { + const string __id = "getObject.()Ljava/lang/String;"; + try { + var __rm = _members.InstanceMethods.InvokeVirtualObjectMethod (__id, this, null); + return JNIEnv.GetString (__rm.Handle, JniHandleOwnership.TransferLocalRef); + } finally { + } + } + } + + } +} diff --git a/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertySubclass.cs b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertySubclass.cs new file mode 100644 index 000000000..2ad3170c4 --- /dev/null +++ b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertySubclass.cs @@ -0,0 +1,81 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; +using Java.Interop; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertySubclass']" + [global::Android.Runtime.Register ("covariant/returntypes/CovariantPropertySubclass", DoNotGenerateAcw=true)] + public partial class CovariantPropertySubclass : global::Covariant.Returntypes.CovariantPropertyClass { + + internal new static readonly JniPeerMembers _members = new JniPeerMembers ("covariant/returntypes/CovariantPropertySubclass", typeof (CovariantPropertySubclass)); + internal static new IntPtr class_ref { + get { + return _members.JniPeerType.PeerReference.Handle; + } + } + + public override global::Java.Interop.JniPeerMembers JniPeerMembers { + get { return _members; } + } + + protected override IntPtr ThresholdClass { + get { return _members.JniPeerType.PeerReference.Handle; } + } + + protected override global::System.Type ThresholdType { + get { return _members.ManagedPeerType; } + } + + protected CovariantPropertySubclass (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertySubclass']/constructor[@name='CovariantPropertySubclass' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe CovariantPropertySubclass () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + const string __id = "()V"; + + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + var __r = _members.InstanceMethods.StartCreateInstance (__id, ((object) this).GetType (), null); + SetHandle (__r.Handle, JniHandleOwnership.TransferLocalRef); + _members.InstanceMethods.FinishCreateInstance (__id, this, null); + } finally { + } + } + + static Delegate cb_getObject; +#pragma warning disable 0169 + static Delegate GetGetObjectHandler () + { + if (cb_getObject == null) + cb_getObject = JNINativeWrapper.CreateDelegate ((Func) n_GetObject); + return cb_getObject; + } + + static IntPtr n_GetObject (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.CovariantPropertySubclass __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.Object); + } +#pragma warning restore 0169 + + public override unsafe global::Java.Lang.Object Object { + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertySubclass']/method[@name='getObject' and count(parameter)=0]" + [Register ("getObject", "()Ljava/lang/String;", "GetGetObjectHandler")] + get { + const string __id = "getObject.()Ljava/lang/String;"; + try { + var __rm = _members.InstanceMethods.InvokeVirtualObjectMethod (__id, this, null); + return JNIEnv.GetString (__rm.Handle, JniHandleOwnership.TransferLocalRef); + } finally { + } + } + } + + } +} diff --git a/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantSubclass.cs b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantSubclass.cs new file mode 100644 index 000000000..782950aca --- /dev/null +++ b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.CovariantSubclass.cs @@ -0,0 +1,80 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; +using Java.Interop; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantSubclass']" + [global::Android.Runtime.Register ("covariant/returntypes/CovariantSubclass", DoNotGenerateAcw=true)] + public partial class CovariantSubclass : global::Covariant.Returntypes.CovariantClass { + + internal new static readonly JniPeerMembers _members = new JniPeerMembers ("covariant/returntypes/CovariantSubclass", typeof (CovariantSubclass)); + internal static new IntPtr class_ref { + get { + return _members.JniPeerType.PeerReference.Handle; + } + } + + public override global::Java.Interop.JniPeerMembers JniPeerMembers { + get { return _members; } + } + + protected override IntPtr ThresholdClass { + get { return _members.JniPeerType.PeerReference.Handle; } + } + + protected override global::System.Type ThresholdType { + get { return _members.ManagedPeerType; } + } + + protected CovariantSubclass (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantSubclass']/constructor[@name='CovariantSubclass' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe CovariantSubclass () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + const string __id = "()V"; + + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + var __r = _members.InstanceMethods.StartCreateInstance (__id, ((object) this).GetType (), null); + SetHandle (__r.Handle, JniHandleOwnership.TransferLocalRef); + _members.InstanceMethods.FinishCreateInstance (__id, this, null); + } finally { + } + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.CovariantSubclass __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantSubclass']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/String;", "GetSomeMethodHandler")] + public override unsafe global::Java.Lang.Object SomeMethod () + { + const string __id = "someMethod.()Ljava/lang/String;"; + try { + var __rm = _members.InstanceMethods.InvokeVirtualObjectMethod (__id, this, null); + return JNIEnv.GetString (__rm.Handle, JniHandleOwnership.TransferLocalRef); + } finally { + } + } + + } +} diff --git a/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.GenericCovariantImplementation.cs b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.GenericCovariantImplementation.cs new file mode 100644 index 000000000..f1cca1fe6 --- /dev/null +++ b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.GenericCovariantImplementation.cs @@ -0,0 +1,80 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; +using Java.Interop; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericCovariantImplementation']" + [global::Android.Runtime.Register ("covariant/returntypes/GenericCovariantImplementation", DoNotGenerateAcw=true)] + public partial class GenericCovariantImplementation : global::Covariant.Returntypes.GenericImplementation { + + internal new static readonly JniPeerMembers _members = new JniPeerMembers ("covariant/returntypes/GenericCovariantImplementation", typeof (GenericCovariantImplementation)); + internal static new IntPtr class_ref { + get { + return _members.JniPeerType.PeerReference.Handle; + } + } + + public override global::Java.Interop.JniPeerMembers JniPeerMembers { + get { return _members; } + } + + protected override IntPtr ThresholdClass { + get { return _members.JniPeerType.PeerReference.Handle; } + } + + protected override global::System.Type ThresholdType { + get { return _members.ManagedPeerType; } + } + + protected GenericCovariantImplementation (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericCovariantImplementation']/constructor[@name='GenericCovariantImplementation' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe GenericCovariantImplementation () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + const string __id = "()V"; + + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + var __r = _members.InstanceMethods.StartCreateInstance (__id, ((object) this).GetType (), null); + SetHandle (__r.Handle, JniHandleOwnership.TransferLocalRef); + _members.InstanceMethods.FinishCreateInstance (__id, this, null); + } finally { + } + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.GenericCovariantImplementation __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericCovariantImplementation']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/String;", "GetSomeMethodHandler")] + public override unsafe global::Java.Lang.Object SomeMethod () + { + const string __id = "someMethod.()Ljava/lang/String;"; + try { + var __rm = _members.InstanceMethods.InvokeVirtualObjectMethod (__id, this, null); + return JNIEnv.GetString (__rm.Handle, JniHandleOwnership.TransferLocalRef); + } finally { + } + } + + } +} diff --git a/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.GenericImplementation.cs b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.GenericImplementation.cs new file mode 100644 index 000000000..e62028321 --- /dev/null +++ b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.GenericImplementation.cs @@ -0,0 +1,86 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; +using Java.Interop; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericImplementation']" + [global::Android.Runtime.Register ("covariant/returntypes/GenericImplementation", DoNotGenerateAcw=true)] + public partial class GenericImplementation : global::Java.Lang.Object, global::Covariant.Returntypes.IGenericInterface { + + internal new static readonly JniPeerMembers _members = new JniPeerMembers ("covariant/returntypes/GenericImplementation", typeof (GenericImplementation)); + internal static new IntPtr class_ref { + get { + return _members.JniPeerType.PeerReference.Handle; + } + } + + public override global::Java.Interop.JniPeerMembers JniPeerMembers { + get { return _members; } + } + + protected override IntPtr ThresholdClass { + get { return _members.JniPeerType.PeerReference.Handle; } + } + + protected override global::System.Type ThresholdType { + get { return _members.ManagedPeerType; } + } + + protected GenericImplementation (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericImplementation']/constructor[@name='GenericImplementation' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe GenericImplementation () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + const string __id = "()V"; + + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + var __r = _members.InstanceMethods.StartCreateInstance (__id, ((object) this).GetType (), null); + SetHandle (__r.Handle, JniHandleOwnership.TransferLocalRef); + _members.InstanceMethods.FinishCreateInstance (__id, this, null); + } finally { + } + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.GenericImplementation __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericImplementation']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/Object;", "GetSomeMethodHandler")] + public virtual unsafe global::Java.Lang.Object SomeMethod () + { + const string __id = "someMethod.()Ljava/lang/Object;"; + try { + var __rm = _members.InstanceMethods.InvokeVirtualObjectMethod (__id, this, null); + return global::Java.Lang.Object.GetObject (__rm.Handle, JniHandleOwnership.TransferLocalRef); + } finally { + } + } + + // This method is explicitly implemented as a member of an instantiated Covariant.Returntypes.IGenericInterface + global::Java.Lang.Object global::Covariant.Returntypes.IGenericInterface.SomeMethod () + { + return global::Java.Interop.JavaObjectExtensions.JavaCast(SomeMethod ()); + } + + } +} diff --git a/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.GenericStringImplementation.cs b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.GenericStringImplementation.cs new file mode 100644 index 000000000..758981553 --- /dev/null +++ b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.GenericStringImplementation.cs @@ -0,0 +1,86 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; +using Java.Interop; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericStringImplementation']" + [global::Android.Runtime.Register ("covariant/returntypes/GenericStringImplementation", DoNotGenerateAcw=true)] + public partial class GenericStringImplementation : global::Java.Lang.Object, global::Covariant.Returntypes.IGenericInterface { + + internal new static readonly JniPeerMembers _members = new JniPeerMembers ("covariant/returntypes/GenericStringImplementation", typeof (GenericStringImplementation)); + internal static new IntPtr class_ref { + get { + return _members.JniPeerType.PeerReference.Handle; + } + } + + public override global::Java.Interop.JniPeerMembers JniPeerMembers { + get { return _members; } + } + + protected override IntPtr ThresholdClass { + get { return _members.JniPeerType.PeerReference.Handle; } + } + + protected override global::System.Type ThresholdType { + get { return _members.ManagedPeerType; } + } + + protected GenericStringImplementation (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericStringImplementation']/constructor[@name='GenericStringImplementation' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe GenericStringImplementation () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + const string __id = "()V"; + + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + var __r = _members.InstanceMethods.StartCreateInstance (__id, ((object) this).GetType (), null); + SetHandle (__r.Handle, JniHandleOwnership.TransferLocalRef); + _members.InstanceMethods.FinishCreateInstance (__id, this, null); + } finally { + } + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.GenericStringImplementation __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.NewString (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericStringImplementation']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/String;", "GetSomeMethodHandler")] + public virtual unsafe string SomeMethod () + { + const string __id = "someMethod.()Ljava/lang/String;"; + try { + var __rm = _members.InstanceMethods.InvokeVirtualObjectMethod (__id, this, null); + return JNIEnv.GetString (__rm.Handle, JniHandleOwnership.TransferLocalRef); + } finally { + } + } + + // This method is explicitly implemented as a member of an instantiated Covariant.Returntypes.IGenericInterface + global::Java.Lang.Object global::Covariant.Returntypes.IGenericInterface.SomeMethod () + { + return SomeMethod ().ToString (); + } + + } +} diff --git a/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.ICovariantInterface.cs b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.ICovariantInterface.cs new file mode 100644 index 000000000..633ef458d --- /dev/null +++ b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.ICovariantInterface.cs @@ -0,0 +1,95 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; +using Java.Interop; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath interface reference: path="/api/package[@name='covariant.returntypes']/interface[@name='CovariantInterface']" + [Register ("covariant/returntypes/CovariantInterface", "", "Covariant.Returntypes.ICovariantInterfaceInvoker")] + public partial interface ICovariantInterface : IJavaObject { + + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/interface[@name='CovariantInterface']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/Object;", "GetSomeMethodHandler:Covariant.Returntypes.ICovariantInterfaceInvoker, Mono.Android, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")] + global::Java.Lang.Object SomeMethod (); + + } + + [global::Android.Runtime.Register ("covariant/returntypes/CovariantInterface", DoNotGenerateAcw=true)] + internal class ICovariantInterfaceInvoker : global::Java.Lang.Object, ICovariantInterface { + + internal new static readonly JniPeerMembers _members = new JniPeerMembers ("covariant/returntypes/CovariantInterface", typeof (ICovariantInterfaceInvoker)); + + static IntPtr java_class_ref { + get { return _members.JniPeerType.PeerReference.Handle; } + } + + public override global::Java.Interop.JniPeerMembers JniPeerMembers { + get { return _members; } + } + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return _members.ManagedPeerType; } + } + + new IntPtr class_ref; + + public static ICovariantInterface GetObject (IntPtr handle, JniHandleOwnership transfer) + { + return global::Java.Lang.Object.GetObject (handle, transfer); + } + + static IntPtr Validate (IntPtr handle) + { + if (!JNIEnv.IsInstanceOf (handle, java_class_ref)) + throw new InvalidCastException (string.Format ("Unable to convert instance of type '{0}' to type '{1}'.", + JNIEnv.GetClassNameFromInstance (handle), "covariant.returntypes.CovariantInterface")); + return handle; + } + + protected override void Dispose (bool disposing) + { + if (this.class_ref != IntPtr.Zero) + JNIEnv.DeleteGlobalRef (this.class_ref); + this.class_ref = IntPtr.Zero; + base.Dispose (disposing); + } + + public ICovariantInterfaceInvoker (IntPtr handle, JniHandleOwnership transfer) : base (Validate (handle), transfer) + { + IntPtr local_ref = JNIEnv.GetObjectClass (((global::Java.Lang.Object) this).Handle); + this.class_ref = JNIEnv.NewGlobalRef (local_ref); + JNIEnv.DeleteLocalRef (local_ref); + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.ICovariantInterface __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + IntPtr id_someMethod; + public unsafe global::Java.Lang.Object SomeMethod () + { + if (id_someMethod == IntPtr.Zero) + id_someMethod = JNIEnv.GetMethodID (class_ref, "someMethod", "()Ljava/lang/Object;"); + return global::Java.Lang.Object.GetObject (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_someMethod), JniHandleOwnership.TransferLocalRef); + } + + } + +} diff --git a/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.ICovariantPropertyInterface.cs b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.ICovariantPropertyInterface.cs new file mode 100644 index 000000000..7338baba2 --- /dev/null +++ b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.ICovariantPropertyInterface.cs @@ -0,0 +1,97 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; +using Java.Interop; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath interface reference: path="/api/package[@name='covariant.returntypes']/interface[@name='CovariantPropertyInterface']" + [Register ("covariant/returntypes/CovariantPropertyInterface", "", "Covariant.Returntypes.ICovariantPropertyInterfaceInvoker")] + public partial interface ICovariantPropertyInterface : IJavaObject { + + global::Java.Lang.Object Object { + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/interface[@name='CovariantPropertyInterface']/method[@name='getObject' and count(parameter)=0]" + [Register ("getObject", "()Ljava/lang/Object;", "GetGetObjectHandler:Covariant.Returntypes.ICovariantPropertyInterfaceInvoker, Mono.Android, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")] get; + } + + } + + [global::Android.Runtime.Register ("covariant/returntypes/CovariantPropertyInterface", DoNotGenerateAcw=true)] + internal class ICovariantPropertyInterfaceInvoker : global::Java.Lang.Object, ICovariantPropertyInterface { + + internal new static readonly JniPeerMembers _members = new JniPeerMembers ("covariant/returntypes/CovariantPropertyInterface", typeof (ICovariantPropertyInterfaceInvoker)); + + static IntPtr java_class_ref { + get { return _members.JniPeerType.PeerReference.Handle; } + } + + public override global::Java.Interop.JniPeerMembers JniPeerMembers { + get { return _members; } + } + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return _members.ManagedPeerType; } + } + + new IntPtr class_ref; + + public static ICovariantPropertyInterface GetObject (IntPtr handle, JniHandleOwnership transfer) + { + return global::Java.Lang.Object.GetObject (handle, transfer); + } + + static IntPtr Validate (IntPtr handle) + { + if (!JNIEnv.IsInstanceOf (handle, java_class_ref)) + throw new InvalidCastException (string.Format ("Unable to convert instance of type '{0}' to type '{1}'.", + JNIEnv.GetClassNameFromInstance (handle), "covariant.returntypes.CovariantPropertyInterface")); + return handle; + } + + protected override void Dispose (bool disposing) + { + if (this.class_ref != IntPtr.Zero) + JNIEnv.DeleteGlobalRef (this.class_ref); + this.class_ref = IntPtr.Zero; + base.Dispose (disposing); + } + + public ICovariantPropertyInterfaceInvoker (IntPtr handle, JniHandleOwnership transfer) : base (Validate (handle), transfer) + { + IntPtr local_ref = JNIEnv.GetObjectClass (((global::Java.Lang.Object) this).Handle); + this.class_ref = JNIEnv.NewGlobalRef (local_ref); + JNIEnv.DeleteLocalRef (local_ref); + } + + static Delegate cb_getObject; +#pragma warning disable 0169 + static Delegate GetGetObjectHandler () + { + if (cb_getObject == null) + cb_getObject = JNINativeWrapper.CreateDelegate ((Func) n_GetObject); + return cb_getObject; + } + + static IntPtr n_GetObject (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.ICovariantPropertyInterface __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.Object); + } +#pragma warning restore 0169 + + IntPtr id_getObject; + public unsafe global::Java.Lang.Object Object { + get { + if (id_getObject == IntPtr.Zero) + id_getObject = JNIEnv.GetMethodID (class_ref, "getObject", "()Ljava/lang/Object;"); + return global::Java.Lang.Object.GetObject (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_getObject), JniHandleOwnership.TransferLocalRef); + } + } + + } + +} diff --git a/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.IGenericInterface.cs b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.IGenericInterface.cs new file mode 100644 index 000000000..7c2dfb32d --- /dev/null +++ b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Covariant.Returntypes.IGenericInterface.cs @@ -0,0 +1,96 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; +using Java.Interop; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath interface reference: path="/api/package[@name='covariant.returntypes']/interface[@name='GenericInterface']" + [Register ("covariant/returntypes/GenericInterface", "", "Covariant.Returntypes.IGenericInterfaceInvoker")] + [global::Java.Interop.JavaTypeParameters (new string [] {"T"})] + public partial interface IGenericInterface : IJavaObject { + + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/interface[@name='GenericInterface']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/Object;", "GetSomeMethodHandler:Covariant.Returntypes.IGenericInterfaceInvoker, Mono.Android, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")] + global::Java.Lang.Object SomeMethod (); + + } + + [global::Android.Runtime.Register ("covariant/returntypes/GenericInterface", DoNotGenerateAcw=true)] + internal class IGenericInterfaceInvoker : global::Java.Lang.Object, IGenericInterface { + + internal new static readonly JniPeerMembers _members = new JniPeerMembers ("covariant/returntypes/GenericInterface", typeof (IGenericInterfaceInvoker)); + + static IntPtr java_class_ref { + get { return _members.JniPeerType.PeerReference.Handle; } + } + + public override global::Java.Interop.JniPeerMembers JniPeerMembers { + get { return _members; } + } + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return _members.ManagedPeerType; } + } + + new IntPtr class_ref; + + public static IGenericInterface GetObject (IntPtr handle, JniHandleOwnership transfer) + { + return global::Java.Lang.Object.GetObject (handle, transfer); + } + + static IntPtr Validate (IntPtr handle) + { + if (!JNIEnv.IsInstanceOf (handle, java_class_ref)) + throw new InvalidCastException (string.Format ("Unable to convert instance of type '{0}' to type '{1}'.", + JNIEnv.GetClassNameFromInstance (handle), "covariant.returntypes.GenericInterface")); + return handle; + } + + protected override void Dispose (bool disposing) + { + if (this.class_ref != IntPtr.Zero) + JNIEnv.DeleteGlobalRef (this.class_ref); + this.class_ref = IntPtr.Zero; + base.Dispose (disposing); + } + + public IGenericInterfaceInvoker (IntPtr handle, JniHandleOwnership transfer) : base (Validate (handle), transfer) + { + IntPtr local_ref = JNIEnv.GetObjectClass (((global::Java.Lang.Object) this).Handle); + this.class_ref = JNIEnv.NewGlobalRef (local_ref); + JNIEnv.DeleteLocalRef (local_ref); + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.IGenericInterface __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + IntPtr id_someMethod; + public unsafe global::Java.Lang.Object SomeMethod () + { + if (id_someMethod == IntPtr.Zero) + id_someMethod = JNIEnv.GetMethodID (class_ref, "someMethod", "()Ljava/lang/Object;"); + return (Java.Lang.Object) global::Java.Lang.Object.GetObject (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_someMethod), JniHandleOwnership.TransferLocalRef); + } + + } + +} diff --git a/tools/generator/Tests/expected.ji/CovariantReturnTypes/Mono.Android.projitems b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Mono.Android.projitems new file mode 100644 index 000000000..73ea4eec3 --- /dev/null +++ b/tools/generator/Tests/expected.ji/CovariantReturnTypes/Mono.Android.projitems @@ -0,0 +1,27 @@ + + + + $(DefineConstants);ANDROID_1;ANDROID_2;ANDROID_3;ANDROID_4 + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tools/generator/Tests/expected.targets b/tools/generator/Tests/expected.targets index cc93a0f1c..3b6401e35 100644 --- a/tools/generator/Tests/expected.targets +++ b/tools/generator/Tests/expected.targets @@ -39,6 +39,45 @@ PreserveNewest + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + PreserveNewest @@ -208,6 +247,45 @@ PreserveNewest + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + PreserveNewest diff --git a/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantClass.cs b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantClass.cs new file mode 100644 index 000000000..f5d32e9f7 --- /dev/null +++ b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantClass.cs @@ -0,0 +1,62 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantClass']" + [global::Android.Runtime.Register ("covariant/returntypes/CovariantClass", DoNotGenerateAcw=true)] + public partial class CovariantClass : global::Java.Lang.Object { + + internal static new IntPtr java_class_handle; + internal static new IntPtr class_ref { + get { + return JNIEnv.FindClass ("covariant/returntypes/CovariantClass", ref java_class_handle); + } + } + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return typeof (CovariantClass); } + } + + protected CovariantClass (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.CovariantClass __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + static IntPtr id_someMethod; + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantClass']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/Object;", "GetSomeMethodHandler")] + public virtual unsafe global::Java.Lang.Object SomeMethod () + { + if (id_someMethod == IntPtr.Zero) + id_someMethod = JNIEnv.GetMethodID (class_ref, "someMethod", "()Ljava/lang/Object;"); + try { + + if (((object) this).GetType () == ThresholdType) + return global::Java.Lang.Object.GetObject (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_someMethod), JniHandleOwnership.TransferLocalRef); + else + return global::Java.Lang.Object.GetObject (JNIEnv.CallNonvirtualObjectMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "someMethod", "()Ljava/lang/Object;")), JniHandleOwnership.TransferLocalRef); + } finally { + } + } + + } +} diff --git a/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantInterfaceImplementation.cs b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantInterfaceImplementation.cs new file mode 100644 index 000000000..e443cd013 --- /dev/null +++ b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantInterfaceImplementation.cs @@ -0,0 +1,90 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantInterfaceImplementation']" + [global::Android.Runtime.Register ("covariant/returntypes/CovariantInterfaceImplementation", DoNotGenerateAcw=true)] + public partial class CovariantInterfaceImplementation : global::Java.Lang.Object, global::Covariant.Returntypes.ICovariantInterface { + + internal static new IntPtr java_class_handle; + internal static new IntPtr class_ref { + get { + return JNIEnv.FindClass ("covariant/returntypes/CovariantInterfaceImplementation", ref java_class_handle); + } + } + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return typeof (CovariantInterfaceImplementation); } + } + + protected CovariantInterfaceImplementation (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + static IntPtr id_ctor; + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantInterfaceImplementation']/constructor[@name='CovariantInterfaceImplementation' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe CovariantInterfaceImplementation () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + if (((object) this).GetType () != typeof (CovariantInterfaceImplementation)) { + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (((object) this).GetType (), "()V"), + JniHandleOwnership.TransferLocalRef); + global::Android.Runtime.JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, "()V"); + return; + } + + if (id_ctor == IntPtr.Zero) + id_ctor = JNIEnv.GetMethodID (class_ref, "", "()V"); + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (class_ref, id_ctor), + JniHandleOwnership.TransferLocalRef); + JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, class_ref, id_ctor); + } finally { + } + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.CovariantInterfaceImplementation __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + static IntPtr id_someMethod; + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantInterfaceImplementation']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/String;", "GetSomeMethodHandler")] + public virtual unsafe global::Java.Lang.Object SomeMethod () + { + if (id_someMethod == IntPtr.Zero) + id_someMethod = JNIEnv.GetMethodID (class_ref, "someMethod", "()Ljava/lang/String;"); + try { + + if (((object) this).GetType () == ThresholdType) + return JNIEnv.GetString (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_someMethod), JniHandleOwnership.TransferLocalRef); + else + return JNIEnv.GetString (JNIEnv.CallNonvirtualObjectMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "someMethod", "()Ljava/lang/String;")), JniHandleOwnership.TransferLocalRef); + } finally { + } + } + + } +} diff --git a/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertyClass.cs b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertyClass.cs new file mode 100644 index 000000000..9cadb0223 --- /dev/null +++ b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertyClass.cs @@ -0,0 +1,63 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertyClass']" + [global::Android.Runtime.Register ("covariant/returntypes/CovariantPropertyClass", DoNotGenerateAcw=true)] + public partial class CovariantPropertyClass : global::Java.Lang.Object { + + internal static new IntPtr java_class_handle; + internal static new IntPtr class_ref { + get { + return JNIEnv.FindClass ("covariant/returntypes/CovariantPropertyClass", ref java_class_handle); + } + } + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return typeof (CovariantPropertyClass); } + } + + protected CovariantPropertyClass (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + static Delegate cb_getObject; +#pragma warning disable 0169 + static Delegate GetGetObjectHandler () + { + if (cb_getObject == null) + cb_getObject = JNINativeWrapper.CreateDelegate ((Func) n_GetObject); + return cb_getObject; + } + + static IntPtr n_GetObject (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.CovariantPropertyClass __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.Object); + } +#pragma warning restore 0169 + + static IntPtr id_getObject; + public virtual unsafe global::Java.Lang.Object Object { + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertyClass']/method[@name='getObject' and count(parameter)=0]" + [Register ("getObject", "()Ljava/lang/Object;", "GetGetObjectHandler")] + get { + if (id_getObject == IntPtr.Zero) + id_getObject = JNIEnv.GetMethodID (class_ref, "getObject", "()Ljava/lang/Object;"); + try { + + if (((object) this).GetType () == ThresholdType) + return global::Java.Lang.Object.GetObject (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_getObject), JniHandleOwnership.TransferLocalRef); + else + return global::Java.Lang.Object.GetObject (JNIEnv.CallNonvirtualObjectMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "getObject", "()Ljava/lang/Object;")), JniHandleOwnership.TransferLocalRef); + } finally { + } + } + } + + } +} diff --git a/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertyImplementation.cs b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertyImplementation.cs new file mode 100644 index 000000000..c520cecd6 --- /dev/null +++ b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertyImplementation.cs @@ -0,0 +1,91 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertyImplementation']" + [global::Android.Runtime.Register ("covariant/returntypes/CovariantPropertyImplementation", DoNotGenerateAcw=true)] + public partial class CovariantPropertyImplementation : global::Java.Lang.Object, global::Covariant.Returntypes.ICovariantPropertyInterface { + + internal static new IntPtr java_class_handle; + internal static new IntPtr class_ref { + get { + return JNIEnv.FindClass ("covariant/returntypes/CovariantPropertyImplementation", ref java_class_handle); + } + } + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return typeof (CovariantPropertyImplementation); } + } + + protected CovariantPropertyImplementation (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + static IntPtr id_ctor; + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertyImplementation']/constructor[@name='CovariantPropertyImplementation' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe CovariantPropertyImplementation () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + if (((object) this).GetType () != typeof (CovariantPropertyImplementation)) { + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (((object) this).GetType (), "()V"), + JniHandleOwnership.TransferLocalRef); + global::Android.Runtime.JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, "()V"); + return; + } + + if (id_ctor == IntPtr.Zero) + id_ctor = JNIEnv.GetMethodID (class_ref, "", "()V"); + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (class_ref, id_ctor), + JniHandleOwnership.TransferLocalRef); + JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, class_ref, id_ctor); + } finally { + } + } + + static Delegate cb_getObject; +#pragma warning disable 0169 + static Delegate GetGetObjectHandler () + { + if (cb_getObject == null) + cb_getObject = JNINativeWrapper.CreateDelegate ((Func) n_GetObject); + return cb_getObject; + } + + static IntPtr n_GetObject (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.CovariantPropertyImplementation __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.Object); + } +#pragma warning restore 0169 + + static IntPtr id_getObject; + public virtual unsafe global::Java.Lang.Object Object { + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertyImplementation']/method[@name='getObject' and count(parameter)=0]" + [Register ("getObject", "()Ljava/lang/String;", "GetGetObjectHandler")] + get { + if (id_getObject == IntPtr.Zero) + id_getObject = JNIEnv.GetMethodID (class_ref, "getObject", "()Ljava/lang/String;"); + try { + + if (((object) this).GetType () == ThresholdType) + return JNIEnv.GetString (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_getObject), JniHandleOwnership.TransferLocalRef); + else + return JNIEnv.GetString (JNIEnv.CallNonvirtualObjectMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "getObject", "()Ljava/lang/String;")), JniHandleOwnership.TransferLocalRef); + } finally { + } + } + } + + } +} diff --git a/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertySubclass.cs b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertySubclass.cs new file mode 100644 index 000000000..1a2358c7e --- /dev/null +++ b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantPropertySubclass.cs @@ -0,0 +1,91 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertySubclass']" + [global::Android.Runtime.Register ("covariant/returntypes/CovariantPropertySubclass", DoNotGenerateAcw=true)] + public partial class CovariantPropertySubclass : global::Covariant.Returntypes.CovariantPropertyClass { + + internal static new IntPtr java_class_handle; + internal static new IntPtr class_ref { + get { + return JNIEnv.FindClass ("covariant/returntypes/CovariantPropertySubclass", ref java_class_handle); + } + } + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return typeof (CovariantPropertySubclass); } + } + + protected CovariantPropertySubclass (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + static IntPtr id_ctor; + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertySubclass']/constructor[@name='CovariantPropertySubclass' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe CovariantPropertySubclass () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + if (((object) this).GetType () != typeof (CovariantPropertySubclass)) { + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (((object) this).GetType (), "()V"), + JniHandleOwnership.TransferLocalRef); + global::Android.Runtime.JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, "()V"); + return; + } + + if (id_ctor == IntPtr.Zero) + id_ctor = JNIEnv.GetMethodID (class_ref, "", "()V"); + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (class_ref, id_ctor), + JniHandleOwnership.TransferLocalRef); + JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, class_ref, id_ctor); + } finally { + } + } + + static Delegate cb_getObject; +#pragma warning disable 0169 + static Delegate GetGetObjectHandler () + { + if (cb_getObject == null) + cb_getObject = JNINativeWrapper.CreateDelegate ((Func) n_GetObject); + return cb_getObject; + } + + static IntPtr n_GetObject (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.CovariantPropertySubclass __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.Object); + } +#pragma warning restore 0169 + + static IntPtr id_getObject; + public override unsafe global::Java.Lang.Object Object { + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantPropertySubclass']/method[@name='getObject' and count(parameter)=0]" + [Register ("getObject", "()Ljava/lang/String;", "GetGetObjectHandler")] + get { + if (id_getObject == IntPtr.Zero) + id_getObject = JNIEnv.GetMethodID (class_ref, "getObject", "()Ljava/lang/String;"); + try { + + if (((object) this).GetType () == ThresholdType) + return JNIEnv.GetString (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_getObject), JniHandleOwnership.TransferLocalRef); + else + return JNIEnv.GetString (JNIEnv.CallNonvirtualObjectMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "getObject", "()Ljava/lang/String;")), JniHandleOwnership.TransferLocalRef); + } finally { + } + } + } + + } +} diff --git a/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantSubclass.cs b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantSubclass.cs new file mode 100644 index 000000000..fa28353e2 --- /dev/null +++ b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.CovariantSubclass.cs @@ -0,0 +1,90 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantSubclass']" + [global::Android.Runtime.Register ("covariant/returntypes/CovariantSubclass", DoNotGenerateAcw=true)] + public partial class CovariantSubclass : global::Covariant.Returntypes.CovariantClass { + + internal static new IntPtr java_class_handle; + internal static new IntPtr class_ref { + get { + return JNIEnv.FindClass ("covariant/returntypes/CovariantSubclass", ref java_class_handle); + } + } + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return typeof (CovariantSubclass); } + } + + protected CovariantSubclass (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + static IntPtr id_ctor; + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantSubclass']/constructor[@name='CovariantSubclass' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe CovariantSubclass () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + if (((object) this).GetType () != typeof (CovariantSubclass)) { + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (((object) this).GetType (), "()V"), + JniHandleOwnership.TransferLocalRef); + global::Android.Runtime.JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, "()V"); + return; + } + + if (id_ctor == IntPtr.Zero) + id_ctor = JNIEnv.GetMethodID (class_ref, "", "()V"); + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (class_ref, id_ctor), + JniHandleOwnership.TransferLocalRef); + JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, class_ref, id_ctor); + } finally { + } + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.CovariantSubclass __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + static IntPtr id_someMethod; + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='CovariantSubclass']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/String;", "GetSomeMethodHandler")] + public override unsafe global::Java.Lang.Object SomeMethod () + { + if (id_someMethod == IntPtr.Zero) + id_someMethod = JNIEnv.GetMethodID (class_ref, "someMethod", "()Ljava/lang/String;"); + try { + + if (((object) this).GetType () == ThresholdType) + return JNIEnv.GetString (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_someMethod), JniHandleOwnership.TransferLocalRef); + else + return JNIEnv.GetString (JNIEnv.CallNonvirtualObjectMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "someMethod", "()Ljava/lang/String;")), JniHandleOwnership.TransferLocalRef); + } finally { + } + } + + } +} diff --git a/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.GenericCovariantImplementation.cs b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.GenericCovariantImplementation.cs new file mode 100644 index 000000000..216e600cf --- /dev/null +++ b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.GenericCovariantImplementation.cs @@ -0,0 +1,90 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericCovariantImplementation']" + [global::Android.Runtime.Register ("covariant/returntypes/GenericCovariantImplementation", DoNotGenerateAcw=true)] + public partial class GenericCovariantImplementation : global::Covariant.Returntypes.GenericImplementation { + + internal static new IntPtr java_class_handle; + internal static new IntPtr class_ref { + get { + return JNIEnv.FindClass ("covariant/returntypes/GenericCovariantImplementation", ref java_class_handle); + } + } + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return typeof (GenericCovariantImplementation); } + } + + protected GenericCovariantImplementation (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + static IntPtr id_ctor; + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericCovariantImplementation']/constructor[@name='GenericCovariantImplementation' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe GenericCovariantImplementation () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + if (((object) this).GetType () != typeof (GenericCovariantImplementation)) { + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (((object) this).GetType (), "()V"), + JniHandleOwnership.TransferLocalRef); + global::Android.Runtime.JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, "()V"); + return; + } + + if (id_ctor == IntPtr.Zero) + id_ctor = JNIEnv.GetMethodID (class_ref, "", "()V"); + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (class_ref, id_ctor), + JniHandleOwnership.TransferLocalRef); + JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, class_ref, id_ctor); + } finally { + } + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.GenericCovariantImplementation __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + static IntPtr id_someMethod; + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericCovariantImplementation']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/String;", "GetSomeMethodHandler")] + public override unsafe global::Java.Lang.Object SomeMethod () + { + if (id_someMethod == IntPtr.Zero) + id_someMethod = JNIEnv.GetMethodID (class_ref, "someMethod", "()Ljava/lang/String;"); + try { + + if (((object) this).GetType () == ThresholdType) + return JNIEnv.GetString (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_someMethod), JniHandleOwnership.TransferLocalRef); + else + return JNIEnv.GetString (JNIEnv.CallNonvirtualObjectMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "someMethod", "()Ljava/lang/String;")), JniHandleOwnership.TransferLocalRef); + } finally { + } + } + + } +} diff --git a/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.GenericImplementation.cs b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.GenericImplementation.cs new file mode 100644 index 000000000..dcbc69de9 --- /dev/null +++ b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.GenericImplementation.cs @@ -0,0 +1,96 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericImplementation']" + [global::Android.Runtime.Register ("covariant/returntypes/GenericImplementation", DoNotGenerateAcw=true)] + public partial class GenericImplementation : global::Java.Lang.Object, global::Covariant.Returntypes.IGenericInterface { + + internal static new IntPtr java_class_handle; + internal static new IntPtr class_ref { + get { + return JNIEnv.FindClass ("covariant/returntypes/GenericImplementation", ref java_class_handle); + } + } + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return typeof (GenericImplementation); } + } + + protected GenericImplementation (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + static IntPtr id_ctor; + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericImplementation']/constructor[@name='GenericImplementation' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe GenericImplementation () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + if (((object) this).GetType () != typeof (GenericImplementation)) { + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (((object) this).GetType (), "()V"), + JniHandleOwnership.TransferLocalRef); + global::Android.Runtime.JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, "()V"); + return; + } + + if (id_ctor == IntPtr.Zero) + id_ctor = JNIEnv.GetMethodID (class_ref, "", "()V"); + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (class_ref, id_ctor), + JniHandleOwnership.TransferLocalRef); + JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, class_ref, id_ctor); + } finally { + } + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.GenericImplementation __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + static IntPtr id_someMethod; + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericImplementation']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/Object;", "GetSomeMethodHandler")] + public virtual unsafe global::Java.Lang.Object SomeMethod () + { + if (id_someMethod == IntPtr.Zero) + id_someMethod = JNIEnv.GetMethodID (class_ref, "someMethod", "()Ljava/lang/Object;"); + try { + + if (((object) this).GetType () == ThresholdType) + return global::Java.Lang.Object.GetObject (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_someMethod), JniHandleOwnership.TransferLocalRef); + else + return global::Java.Lang.Object.GetObject (JNIEnv.CallNonvirtualObjectMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "someMethod", "()Ljava/lang/Object;")), JniHandleOwnership.TransferLocalRef); + } finally { + } + } + + // This method is explicitly implemented as a member of an instantiated Covariant.Returntypes.IGenericInterface + global::Java.Lang.Object global::Covariant.Returntypes.IGenericInterface.SomeMethod () + { + return global::Java.Interop.JavaObjectExtensions.JavaCast(SomeMethod ()); + } + + } +} diff --git a/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.GenericStringImplementation.cs b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.GenericStringImplementation.cs new file mode 100644 index 000000000..78e19e9a0 --- /dev/null +++ b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.GenericStringImplementation.cs @@ -0,0 +1,96 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath class reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericStringImplementation']" + [global::Android.Runtime.Register ("covariant/returntypes/GenericStringImplementation", DoNotGenerateAcw=true)] + public partial class GenericStringImplementation : global::Java.Lang.Object, global::Covariant.Returntypes.IGenericInterface { + + internal static new IntPtr java_class_handle; + internal static new IntPtr class_ref { + get { + return JNIEnv.FindClass ("covariant/returntypes/GenericStringImplementation", ref java_class_handle); + } + } + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return typeof (GenericStringImplementation); } + } + + protected GenericStringImplementation (IntPtr javaReference, JniHandleOwnership transfer) : base (javaReference, transfer) {} + + static IntPtr id_ctor; + // Metadata.xml XPath constructor reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericStringImplementation']/constructor[@name='GenericStringImplementation' and count(parameter)=0]" + [Register (".ctor", "()V", "")] + public unsafe GenericStringImplementation () + : base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer) + { + if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero) + return; + + try { + if (((object) this).GetType () != typeof (GenericStringImplementation)) { + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (((object) this).GetType (), "()V"), + JniHandleOwnership.TransferLocalRef); + global::Android.Runtime.JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, "()V"); + return; + } + + if (id_ctor == IntPtr.Zero) + id_ctor = JNIEnv.GetMethodID (class_ref, "", "()V"); + SetHandle ( + global::Android.Runtime.JNIEnv.StartCreateInstance (class_ref, id_ctor), + JniHandleOwnership.TransferLocalRef); + JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, class_ref, id_ctor); + } finally { + } + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.GenericStringImplementation __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.NewString (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + static IntPtr id_someMethod; + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/class[@name='GenericStringImplementation']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/String;", "GetSomeMethodHandler")] + public virtual unsafe string SomeMethod () + { + if (id_someMethod == IntPtr.Zero) + id_someMethod = JNIEnv.GetMethodID (class_ref, "someMethod", "()Ljava/lang/String;"); + try { + + if (((object) this).GetType () == ThresholdType) + return JNIEnv.GetString (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_someMethod), JniHandleOwnership.TransferLocalRef); + else + return JNIEnv.GetString (JNIEnv.CallNonvirtualObjectMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "someMethod", "()Ljava/lang/String;")), JniHandleOwnership.TransferLocalRef); + } finally { + } + } + + // This method is explicitly implemented as a member of an instantiated Covariant.Returntypes.IGenericInterface + global::Java.Lang.Object global::Covariant.Returntypes.IGenericInterface.SomeMethod () + { + return SomeMethod ().ToString (); + } + + } +} diff --git a/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.ICovariantInterface.cs b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.ICovariantInterface.cs new file mode 100644 index 000000000..fdf1f23f1 --- /dev/null +++ b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.ICovariantInterface.cs @@ -0,0 +1,86 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath interface reference: path="/api/package[@name='covariant.returntypes']/interface[@name='CovariantInterface']" + [Register ("covariant/returntypes/CovariantInterface", "", "Covariant.Returntypes.ICovariantInterfaceInvoker")] + public partial interface ICovariantInterface : IJavaObject { + + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/interface[@name='CovariantInterface']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/Object;", "GetSomeMethodHandler:Covariant.Returntypes.ICovariantInterfaceInvoker, Mono.Android, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")] + global::Java.Lang.Object SomeMethod (); + + } + + [global::Android.Runtime.Register ("covariant/returntypes/CovariantInterface", DoNotGenerateAcw=true)] + internal class ICovariantInterfaceInvoker : global::Java.Lang.Object, ICovariantInterface { + + static IntPtr java_class_ref = JNIEnv.FindClass ("covariant/returntypes/CovariantInterface"); + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return typeof (ICovariantInterfaceInvoker); } + } + + new IntPtr class_ref; + + public static ICovariantInterface GetObject (IntPtr handle, JniHandleOwnership transfer) + { + return global::Java.Lang.Object.GetObject (handle, transfer); + } + + static IntPtr Validate (IntPtr handle) + { + if (!JNIEnv.IsInstanceOf (handle, java_class_ref)) + throw new InvalidCastException (string.Format ("Unable to convert instance of type '{0}' to type '{1}'.", + JNIEnv.GetClassNameFromInstance (handle), "covariant.returntypes.CovariantInterface")); + return handle; + } + + protected override void Dispose (bool disposing) + { + if (this.class_ref != IntPtr.Zero) + JNIEnv.DeleteGlobalRef (this.class_ref); + this.class_ref = IntPtr.Zero; + base.Dispose (disposing); + } + + public ICovariantInterfaceInvoker (IntPtr handle, JniHandleOwnership transfer) : base (Validate (handle), transfer) + { + IntPtr local_ref = JNIEnv.GetObjectClass (((global::Java.Lang.Object) this).Handle); + this.class_ref = JNIEnv.NewGlobalRef (local_ref); + JNIEnv.DeleteLocalRef (local_ref); + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.ICovariantInterface __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + IntPtr id_someMethod; + public unsafe global::Java.Lang.Object SomeMethod () + { + if (id_someMethod == IntPtr.Zero) + id_someMethod = JNIEnv.GetMethodID (class_ref, "someMethod", "()Ljava/lang/Object;"); + return global::Java.Lang.Object.GetObject (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_someMethod), JniHandleOwnership.TransferLocalRef); + } + + } + +} diff --git a/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.ICovariantPropertyInterface.cs b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.ICovariantPropertyInterface.cs new file mode 100644 index 000000000..9ac9230ba --- /dev/null +++ b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.ICovariantPropertyInterface.cs @@ -0,0 +1,88 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath interface reference: path="/api/package[@name='covariant.returntypes']/interface[@name='CovariantPropertyInterface']" + [Register ("covariant/returntypes/CovariantPropertyInterface", "", "Covariant.Returntypes.ICovariantPropertyInterfaceInvoker")] + public partial interface ICovariantPropertyInterface : IJavaObject { + + global::Java.Lang.Object Object { + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/interface[@name='CovariantPropertyInterface']/method[@name='getObject' and count(parameter)=0]" + [Register ("getObject", "()Ljava/lang/Object;", "GetGetObjectHandler:Covariant.Returntypes.ICovariantPropertyInterfaceInvoker, Mono.Android, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")] get; + } + + } + + [global::Android.Runtime.Register ("covariant/returntypes/CovariantPropertyInterface", DoNotGenerateAcw=true)] + internal class ICovariantPropertyInterfaceInvoker : global::Java.Lang.Object, ICovariantPropertyInterface { + + static IntPtr java_class_ref = JNIEnv.FindClass ("covariant/returntypes/CovariantPropertyInterface"); + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return typeof (ICovariantPropertyInterfaceInvoker); } + } + + new IntPtr class_ref; + + public static ICovariantPropertyInterface GetObject (IntPtr handle, JniHandleOwnership transfer) + { + return global::Java.Lang.Object.GetObject (handle, transfer); + } + + static IntPtr Validate (IntPtr handle) + { + if (!JNIEnv.IsInstanceOf (handle, java_class_ref)) + throw new InvalidCastException (string.Format ("Unable to convert instance of type '{0}' to type '{1}'.", + JNIEnv.GetClassNameFromInstance (handle), "covariant.returntypes.CovariantPropertyInterface")); + return handle; + } + + protected override void Dispose (bool disposing) + { + if (this.class_ref != IntPtr.Zero) + JNIEnv.DeleteGlobalRef (this.class_ref); + this.class_ref = IntPtr.Zero; + base.Dispose (disposing); + } + + public ICovariantPropertyInterfaceInvoker (IntPtr handle, JniHandleOwnership transfer) : base (Validate (handle), transfer) + { + IntPtr local_ref = JNIEnv.GetObjectClass (((global::Java.Lang.Object) this).Handle); + this.class_ref = JNIEnv.NewGlobalRef (local_ref); + JNIEnv.DeleteLocalRef (local_ref); + } + + static Delegate cb_getObject; +#pragma warning disable 0169 + static Delegate GetGetObjectHandler () + { + if (cb_getObject == null) + cb_getObject = JNINativeWrapper.CreateDelegate ((Func) n_GetObject); + return cb_getObject; + } + + static IntPtr n_GetObject (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.ICovariantPropertyInterface __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.Object); + } +#pragma warning restore 0169 + + IntPtr id_getObject; + public unsafe global::Java.Lang.Object Object { + get { + if (id_getObject == IntPtr.Zero) + id_getObject = JNIEnv.GetMethodID (class_ref, "getObject", "()Ljava/lang/Object;"); + return global::Java.Lang.Object.GetObject (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_getObject), JniHandleOwnership.TransferLocalRef); + } + } + + } + +} diff --git a/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.IGenericInterface.cs b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.IGenericInterface.cs new file mode 100644 index 000000000..3ee4ba4d0 --- /dev/null +++ b/tools/generator/Tests/expected/CovariantReturnTypes/Covariant.Returntypes.IGenericInterface.cs @@ -0,0 +1,87 @@ +using System; +using System.Collections.Generic; +using Android.Runtime; + +namespace Covariant.Returntypes { + + // Metadata.xml XPath interface reference: path="/api/package[@name='covariant.returntypes']/interface[@name='GenericInterface']" + [Register ("covariant/returntypes/GenericInterface", "", "Covariant.Returntypes.IGenericInterfaceInvoker")] + [global::Java.Interop.JavaTypeParameters (new string [] {"T"})] + public partial interface IGenericInterface : IJavaObject { + + // Metadata.xml XPath method reference: path="/api/package[@name='covariant.returntypes']/interface[@name='GenericInterface']/method[@name='someMethod' and count(parameter)=0]" + [Register ("someMethod", "()Ljava/lang/Object;", "GetSomeMethodHandler:Covariant.Returntypes.IGenericInterfaceInvoker, Mono.Android, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")] + global::Java.Lang.Object SomeMethod (); + + } + + [global::Android.Runtime.Register ("covariant/returntypes/GenericInterface", DoNotGenerateAcw=true)] + internal class IGenericInterfaceInvoker : global::Java.Lang.Object, IGenericInterface { + + static IntPtr java_class_ref = JNIEnv.FindClass ("covariant/returntypes/GenericInterface"); + + protected override IntPtr ThresholdClass { + get { return class_ref; } + } + + protected override global::System.Type ThresholdType { + get { return typeof (IGenericInterfaceInvoker); } + } + + new IntPtr class_ref; + + public static IGenericInterface GetObject (IntPtr handle, JniHandleOwnership transfer) + { + return global::Java.Lang.Object.GetObject (handle, transfer); + } + + static IntPtr Validate (IntPtr handle) + { + if (!JNIEnv.IsInstanceOf (handle, java_class_ref)) + throw new InvalidCastException (string.Format ("Unable to convert instance of type '{0}' to type '{1}'.", + JNIEnv.GetClassNameFromInstance (handle), "covariant.returntypes.GenericInterface")); + return handle; + } + + protected override void Dispose (bool disposing) + { + if (this.class_ref != IntPtr.Zero) + JNIEnv.DeleteGlobalRef (this.class_ref); + this.class_ref = IntPtr.Zero; + base.Dispose (disposing); + } + + public IGenericInterfaceInvoker (IntPtr handle, JniHandleOwnership transfer) : base (Validate (handle), transfer) + { + IntPtr local_ref = JNIEnv.GetObjectClass (((global::Java.Lang.Object) this).Handle); + this.class_ref = JNIEnv.NewGlobalRef (local_ref); + JNIEnv.DeleteLocalRef (local_ref); + } + + static Delegate cb_someMethod; +#pragma warning disable 0169 + static Delegate GetSomeMethodHandler () + { + if (cb_someMethod == null) + cb_someMethod = JNINativeWrapper.CreateDelegate ((Func) n_SomeMethod); + return cb_someMethod; + } + + static IntPtr n_SomeMethod (IntPtr jnienv, IntPtr native__this) + { + global::Covariant.Returntypes.IGenericInterface __this = global::Java.Lang.Object.GetObject (jnienv, native__this, JniHandleOwnership.DoNotTransfer); + return JNIEnv.ToLocalJniHandle (__this.SomeMethod ()); + } +#pragma warning restore 0169 + + IntPtr id_someMethod; + public unsafe global::Java.Lang.Object SomeMethod () + { + if (id_someMethod == IntPtr.Zero) + id_someMethod = JNIEnv.GetMethodID (class_ref, "someMethod", "()Ljava/lang/Object;"); + return (Java.Lang.Object) global::Java.Lang.Object.GetObject (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_someMethod), JniHandleOwnership.TransferLocalRef); + } + + } + +} diff --git a/tools/generator/Tests/expected/CovariantReturnTypes/CovariantReturnTypes.xml b/tools/generator/Tests/expected/CovariantReturnTypes/CovariantReturnTypes.xml new file mode 100644 index 000000000..e901fce8f --- /dev/null +++ b/tools/generator/Tests/expected/CovariantReturnTypes/CovariantReturnTypes.xml @@ -0,0 +1,141 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tools/generator/Tests/generator-Tests.csproj b/tools/generator/Tests/generator-Tests.csproj index 75a00cf64..80fdb1049 100644 --- a/tools/generator/Tests/generator-Tests.csproj +++ b/tools/generator/Tests/generator-Tests.csproj @@ -65,6 +65,7 @@ +