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);
}
