unsafe object InvokeInstanceMethod(IJavaPeerable self, JniArgumentValue *arguments) { var e = GetSignatureReturnTypeStartIndex(); switch (JniSignature [e + 1]) { case 'Z': return(members.InstanceMethods.InvokeVirtualBooleanMethod(JniSignature, self, arguments)); case 'B': return(members.InstanceMethods.InvokeVirtualSByteMethod(JniSignature, self, arguments)); case 'C': return(members.InstanceMethods.InvokeVirtualCharMethod(JniSignature, self, arguments)); case 'S': return(members.InstanceMethods.InvokeVirtualInt16Method(JniSignature, self, arguments)); case 'I': return(members.InstanceMethods.InvokeVirtualInt32Method(JniSignature, self, arguments)); case 'J': return(members.InstanceMethods.InvokeVirtualInt64Method(JniSignature, self, arguments)); case 'F': return(members.InstanceMethods.InvokeVirtualSingleMethod(JniSignature, self, arguments)); case 'D': return(members.InstanceMethods.InvokeVirtualDoubleMethod(JniSignature, self, arguments)); case 'L': case '[': var lref = members.InstanceMethods.InvokeVirtualObjectMethod(JniSignature, self, arguments); return(ToReturnValue(ref lref, JniSignature, e + 1)); case 'V': members.InstanceMethods.InvokeVirtualVoidMethod(JniSignature, self, arguments); return(null); default: throw new NotSupportedException("Unsupported argument type: " + JniSignature.Substring(e + 1)); } }
public void Generate(StreamWriter sw, string indent, CodeGenerationOptions opt, GenBase type, bool generate_callbacks) { if (!IsValid) { return; } bool gen_as_formatted = IsReturnCharSequence; if (generate_callbacks && IsVirtual) { GenerateCallback(sw, indent, opt, type, null, gen_as_formatted); } string name_and_jnisig = JavaName + JniSignature.Replace("java/lang/CharSequence", "java/lang/String"); bool gen_string_overload = !IsOverride && Parameters.HasCharSequence && !type.ContainsMethod(name_and_jnisig); string static_arg = IsStatic ? " static" : String.Empty; string virt_ov = IsOverride ? " override" : IsVirtual ? " virtual" : String.Empty; if ((string.IsNullOrEmpty(virt_ov) || virt_ov == " virtual") && type.RequiresNew(AdjustedName)) { virt_ov = " new" + virt_ov; } string seal = IsOverride && IsFinal ? " sealed" : null; string ret = opt.GetOutputName(RetVal.FullName); GenerateIdField(sw, indent, opt); if (DeclaringType.IsGeneratable) { sw.WriteLine("{0}// Metadata.xml XPath method reference: path=\"{1}\"", indent, GetMetadataXPathReference(this.DeclaringType)); } if (Deprecated != null) { sw.WriteLine("{0}[Obsolete (@\"{1}\")]", indent, Deprecated.Replace("\"", "\"\"")); } if (IsReturnEnumified) { sw.WriteLine("{0}[return:global::Android.Runtime.GeneratedEnum]", indent); } sw.WriteLine("{0}[Register (\"{1}\", \"{2}\", \"{3}\"{4})]", indent, JavaName, JniSignature, IsVirtual ? ConnectorName : String.Empty, this.AdditionalAttributeString()); GenerateCustomAttributes(sw, indent); sw.WriteLine("{0}{1}{2}{3}{4} unsafe {5} {6} ({7})", indent, Visibility, static_arg, virt_ov, seal, ret, AdjustedName, GenBase.GetSignature(this, opt)); sw.WriteLine("{0}{{", indent); GenerateBody(sw, indent + "\t", opt); sw.WriteLine("{0}}}", indent); sw.WriteLine(); //NOTE: Invokers are the only place false is passed for generate_callbacks, they do not need string overloads if (generate_callbacks && (gen_string_overload || gen_as_formatted)) { GenerateStringOverload(sw, indent, opt); } GenerateAsyncWrapper(sw, indent, opt); }
protected int GetSignatureReturnTypeStartIndex() { int n = JniSignature.IndexOf(')'); if (n == JniSignature.Length - 1) { throw new NotSupportedException( string.Format("Could not determine method return type from signature '{0}'.", JniSignature)); } return(n); }