void GenerateEventArgs(Method m, StreamWriter sw, string indent, CodeGenerationOptions opt)
{
string args_name = GetArgsName(m);
if (m.RetVal.IsVoid || m.IsEventHandlerWithHandledProperty)
{
if (!m.IsSimpleEventHandler || m.IsEventHandlerWithHandledProperty)
{
sw.WriteLine("{0}public partial class {1} : global::System.EventArgs {{", indent, args_name);
sw.WriteLine();
var signature = m.Parameters.GetSignatureDropSender(opt);
sw.WriteLine("{0}\tpublic {1} ({2}{3}{4})", indent, args_name,
m.IsEventHandlerWithHandledProperty ? "bool handled" : "",
(m.IsEventHandlerWithHandledProperty && signature.Length != 0) ? ", " : "",
signature);
sw.WriteLine("{0}\t{{", indent);
if (m.IsEventHandlerWithHandledProperty)
{
sw.WriteLine("{0}\t\tthis.handled = handled;", indent);
}
foreach (Parameter p in m.Parameters)
{
if (!p.IsSender)
{
sw.WriteLine("{0}\t\tthis.{1} = {1};", indent, opt.GetSafeIdentifier(p.Name));
}
}
sw.WriteLine("{0}\t}}", indent);
if (m.IsEventHandlerWithHandledProperty)
{
sw.WriteLine();
sw.WriteLine("{0}\tbool handled;", indent);
sw.WriteLine("{0}\tpublic bool Handled {{", indent);
sw.WriteLine("{0}\t\tget {{ return handled; }}", indent);
sw.WriteLine("{0}\t\tset {{ handled = value; }}", indent);
sw.WriteLine("{0}\t}}", indent);
}
foreach (Parameter p in m.Parameters)
{
if (p.IsSender)
{
continue;
}
sw.WriteLine();
sw.WriteLine("{0}\t{1} {2};", indent, opt.GetOutputName(p.Type), opt.GetSafeIdentifier(p.Name));
// AbsListView.IMultiChoiceModeListener.onItemCheckedStateChanged() hit this strict name check, at parameter "@checked".
sw.WriteLine("{0}\tpublic {1} {2} {{", indent, opt.GetOutputName(p.Type), p.PropertyName);
sw.WriteLine("{0}\t\tget {{ return {1}; }}", indent, opt.GetSafeIdentifier(p.Name));
sw.WriteLine("{0}\t}}", indent);
}
sw.WriteLine("{0}}}", indent);
sw.WriteLine();
}
}
else
{
sw.WriteLine("{0}public delegate {1} {2} ({3});", indent, opt.GetOutputName(m.RetVal.FullName), GetEventDelegateName(m), GenBase.GetSignature(m, opt));
sw.WriteLine();
}
}
public string GetCall(CodeGenerationOptions opt)
{
var rgm = sym as IRequireGenericMarshal;
var c = rgm != null
? opt.GetSafeIdentifier(rgm.ToInteroperableJavaObject(Name))
: ToNative(opt);
c = opt.GetSafeIdentifier(c);
if (opt.CodeGenerationTarget == CodeGenerationTarget.XamarinAndroid)
{
return(c);
}
if (sym.NativeType != "IntPtr")
{
return(c);
}
if (!NeedsPrep)
{
return(c);
}
if (sym.PreCall(opt, Name).Length == 0)
{
return(string.Format("({0} == null) ? IntPtr.Zero : {0}.Handle", c));
}
return(c);
}
public string[] PostCallback(CodeGenerationOptions opt, string var_name)
{
string[] result = new string [2];
result [0] = String.Format("if ({0} != null)", opt.GetSafeIdentifier(var_name));
result [1] = String.Format("\tJNIEnv.CopyArray ({0}, {1});", opt.GetSafeIdentifier(var_name), opt.GetSafeIdentifier(SymbolTable.GetNativeName(var_name)));
return(result);
}
public string[] PostCall(CodeGenerationOptions opt, string var_name)
{
string managed_name = opt.GetSafeIdentifier(var_name);
string native_name = opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name));
if (opt.CodeGenerationTarget == CodeGenerationTarget.JavaInterop1)
{
if (IsParams)
{
return(new[] {
$"if ({managed_name} != null) {{",
$"\t{native_name}.CopyTo ({managed_name}, 0);",
$"\t{native_name}.Dispose ();",
$"}}",
});
}
return(new[] {
$"if ({managed_name} != null) {{",
$"\t{native_name}.DisposeUnlessReferenced ();",
$"}}",
});
}
return(new[] {
$"if ({managed_name} != null) {{",
$"\tJNIEnv.CopyArray ({native_name}, {managed_name});",
$"\tJNIEnv.DeleteLocalRef ({native_name});",
$"}}",
});
}
internal override void WriteFieldSetBody(Field field, StreamWriter sw, string indent, CodeGenerationOptions opt)
{
sw.WriteLine("{0}if ({1} == IntPtr.Zero)", indent, field.ID);
sw.WriteLine("{0}\t{1} = JNIEnv.Get{2}FieldID (class_ref, \"{3}\", \"{4}\");", indent, field.ID, field.IsStatic ? "Static" : String.Empty, field.JavaName, field.Symbol.JniName);
string arg;
bool have_prep = false;
if (field.Symbol.IsArray)
{
arg = opt.GetSafeIdentifier(SymbolTable.GetNativeName("value"));
sw.WriteLine("{0}IntPtr {1} = global::Android.Runtime.JavaArray<{2}>.ToLocalJniHandle (value);", indent, arg, opt.GetOutputName(field.Symbol.ElementType));
}
else
{
foreach (string prep in field.SetParameters.GetCallPrep(opt))
{
have_prep = true;
sw.WriteLine("{0}{1}", indent, prep);
}
arg = field.SetParameters [0].ToNative(opt);
if (field.SetParameters.HasCleanup && !have_prep)
{
arg = opt.GetSafeIdentifier(SymbolTable.GetNativeName("value"));
sw.WriteLine("{0}IntPtr {1} = JNIEnv.ToLocalJniHandle (value);", indent, arg);
}
}
sw.WriteLine("{0}try {{", indent);
sw.WriteLine("{0}\tJNIEnv.Set{1}Field ({2}, {3}, {4});",
indent,
field.IsStatic
? "Static"
: String.Empty,
field.IsStatic
? "class_ref"
: opt.ContextType.GetObjectHandleProperty("this"),
field.ID,
arg);
sw.WriteLine("{0}}} finally {{", indent);
if (field.Symbol.IsArray)
{
sw.WriteLine("{0}\tJNIEnv.DeleteLocalRef ({1});", indent, arg);
}
else
{
foreach (string cleanup in field.SetParameters.GetCallCleanup(opt))
{
sw.WriteLine("{0}\t{1}", indent, cleanup);
}
if (field.SetParameters.HasCleanup && !have_prep)
{
sw.WriteLine("{0}\tJNIEnv.DeleteLocalRef ({1});", indent, arg);
}
}
sw.WriteLine("{0}}}", indent);
}
internal override void WriteFieldSetBody(Field field, TextWriter writer, string indent, CodeGenerationOptions opt, GenBase type)
{
writer.WriteLine("{0}const string __id = \"{1}.{2}\";", indent, field.JavaName, field.Symbol.JniName);
writer.WriteLine();
var invokeType = GetInvokeType(field.GetMethodPrefix);
var indirect = field.IsStatic ? "StaticFields" : "InstanceFields";
string arg;
bool have_prep = false;
if (field.Symbol.IsArray)
{
arg = opt.GetSafeIdentifier(SymbolTable.GetNativeName("value"));
writer.WriteLine("{0}IntPtr {1} = global::Android.Runtime.JavaArray<{2}>.ToLocalJniHandle (value);", indent, arg, opt.GetOutputName(field.Symbol.ElementType));
}
else
{
foreach (string prep in field.SetParameters.GetCallPrep(opt))
{
have_prep = true;
writer.WriteLine("{0}{1}", indent, prep);
}
arg = field.SetParameters [0].ToNative(opt);
if (field.SetParameters.HasCleanup && !have_prep)
{
arg = opt.GetSafeIdentifier(SymbolTable.GetNativeName("value"));
writer.WriteLine("{0}IntPtr {1} = global::Android.Runtime.JNIEnv.ToLocalJniHandle (value);", indent, arg);
}
}
writer.WriteLine("{0}try {{", indent);
writer.WriteLine("{0}\t_members.{1}.SetValue (__id{2}, {3});",
indent,
indirect,
field.IsStatic ? "" : ", this",
invokeType != "Object" ? arg : "new JniObjectReference (" + arg + ")");
writer.WriteLine("{0}}} finally {{", indent);
if (field.Symbol.IsArray)
{
writer.WriteLine("{0}\tglobal::Android.Runtime.JNIEnv.DeleteLocalRef ({1});", indent, arg);
}
else
{
foreach (string cleanup in field.SetParameters.GetCallCleanup(opt))
{
writer.WriteLine("{0}\t{1}", indent, cleanup);
}
if (field.SetParameters.HasCleanup && !have_prep)
{
writer.WriteLine("{0}\tglobal::Android.Runtime.JNIEnv.DeleteLocalRef ({1});", indent, arg);
}
}
writer.WriteLine("{0}}}", indent);
}
public string[] PreCall(CodeGenerationOptions opt, string var_name)
{
return(new string[] {
string.Format("IntPtr {0} = global::Android.Runtime.{1}Adapter.ToLocalJniHandle ({2});",
opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name)),
base_name,
opt.GetSafeIdentifier(var_name)),
});
}
public string[] PreCall(CodeGenerationOptions opt, string var_name)
{
return(new string[] {
string.Format("var {0} = {2};",
opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name)),
GetManagedTypeName(opt),
opt.GetSafeIdentifier(var_name)),
});
}
public string[] PreCall(CodeGenerationOptions opt, string var_name)
{
return(new string[] {
string.Format("IntPtr {0} = {1}.ToLocalJniHandle ({2});",
opt.GetSafeIdentifier(SymbolTable.GetNativeName(var_name)),
GetManagedTypeName(opt),
opt.GetSafeIdentifier(var_name)),
});
}
public string[] PostCall(CodeGenerationOptions opt, string var_name)
{
string native_name = opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name));
string[] result = new string [2];
result [0] = String.Format("if ({0} != null)", opt.GetSafeIdentifier(var_name));
result [1] = String.Format("\t{0}.CopyTo({1}, 0);", native_name, opt.GetSafeIdentifier(var_name));
return(result);
}
public string[] PreCallback(CodeGenerationOptions opt, string var_name, bool owned)
{
return(new string[] {
string.Format("var {0} = global::Java.Util.InteroperableArrays.ToLocal{1} ({2}, {3});",
opt.GetSafeIdentifier(var_name),
GetManagedTypeName(opt),
opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name)),
owned ? "JniHandleOwnership.TransferLocalRef" : "JniHandleOwnership.DoNotTransfer"),
});
}
public string[] PreCallback(CodeGenerationOptions opt, string var_name, bool owned)
{
return(new string[] {
string.Format("var {0} = {1}.FromJniHandle ({2}, {3});",
opt.GetSafeIdentifier(var_name),
GetManagedTypeName(opt),
opt.GetSafeIdentifier(SymbolTable.GetNativeName(var_name)),
owned ? "JniHandleOwnership.TransferLocalRef" : "JniHandleOwnership.DoNotTransfer"),
});
}
void GenerateEventOrProperty(Method m, StreamWriter sw, string indent, ClassGen target, CodeGenerationOptions opt, string name, string connector_fmt, string add, string remove)
{
if (m.EventName == string.Empty)
{
return;
}
string nameSpec = Methods.Count > 1 ? m.AdjustedName : String.Empty;
int idx = FullName.LastIndexOf(".");
int start = Name.StartsWith("IOn") ? 3 : 1;
string full_delegate_name = FullName.Substring(0, idx + 1) + Name.Substring(start, Name.Length - start - 8) + nameSpec;
if (m.IsSimpleEventHandler)
{
full_delegate_name = "EventHandler";
}
else if (m.RetVal.IsVoid || m.IsEventHandlerWithHandledProperty)
{
full_delegate_name = "EventHandler<" + FullName.Substring(0, idx + 1) + GetArgsName(m) + ">";
}
else
{
full_delegate_name += "Handler";
}
if (m.RetVal.IsVoid || m.IsEventHandlerWithHandledProperty)
{
if (opt.GetSafeIdentifier(name) != name)
{
Report.Warning(0, Report.WarningInterfaceGen + 5, "event name for {0}.{1} is invalid. `eventName' or `argsType` can be used to assign a valid member name.", FullName, name);
return;
}
else
{
GenerateEvent(sw, indent, opt, name, nameSpec, m.AdjustedName, full_delegate_name, !m.Parameters.HasSender, connector_fmt, add, remove);
}
}
else
{
if (opt.GetSafeIdentifier(name) != name)
{
Report.Warning(0, Report.WarningInterfaceGen + 6, "event property name for {0}.{1} is invalid. `eventName' or `argsType` can be used to assign a valid member name.", FullName, name);
return;
}
sw.WriteLine("{0}WeakReference weak_implementor_{1};", indent, name);
sw.WriteLine("{0}{1}Implementor Impl{2} {{", indent, opt.GetOutputName(FullName), name);
sw.WriteLine("{0}\tget {{", indent);
sw.WriteLine("{0}\t\tif (weak_implementor_{1} == null || !weak_implementor_{1}.IsAlive)", indent, name);
sw.WriteLine("{0}\t\t\treturn null;", indent);
sw.WriteLine("{0}\t\treturn weak_implementor_{1}.Target as {2}Implementor;", indent, name, opt.GetOutputName(FullName));
sw.WriteLine("{0}\t}}", indent);
sw.WriteLine("{0}\tset {{ weak_implementor_{1} = new WeakReference (value, true); }}", indent, name);
sw.WriteLine("{0}}}", indent);
sw.WriteLine();
GenerateProperty(sw, indent, opt, name, nameSpec, m.AdjustedName, connector_fmt, full_delegate_name);
}
}
public string[] PostCall(CodeGenerationOptions opt, string var_name)
{
string native_name = opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name));
string[] result = new string [4];
result [0] = String.Format("if ({0} != null) {{", opt.GetSafeIdentifier(var_name));
result [1] = String.Format("\tJNIEnv.CopyArray ({0}, {1});", native_name, opt.GetSafeIdentifier(var_name));
result [2] = String.Format("\tJNIEnv.DeleteLocalRef ({0});", native_name);
result [3] = "}";
return(result);
}
public string[] PreCall(CodeGenerationOptions opt, string var_name)
{
string managed_name = opt.GetSafeIdentifier(var_name);
string native_name = opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name));
if (opt.CodeGenerationTarget == CodeGenerationTarget.JavaInterop1)
{
return(new[] {
$"var {native_name} = global::{GetJavaInterop1MarshalMethod ()} ({managed_name});",
});
}
return(new string[] { String.Format("IntPtr {0} = JNIEnv.NewArray ({1});", opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name)), opt.GetSafeIdentifier(var_name)) });
}
public string[] PostCall(CodeGenerationOptions opt, string var_name)
{
string native_name = opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name));
if (opt.CodeGenerationTarget == CodeGenerationTarget.JavaInterop1)
{
return(new[] {
$"global::Java.Interop.JniObjectReference.Dispose (ref {native_name});",
});
}
return(new string[] {
string.Format("JNIEnv.DeleteLocalRef ({0});", opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name))),
});
}
public string[] PreCallback(CodeGenerationOptions opt, string var_name, bool owned)
{
var rgm = this as IRequireGenericMarshal;
return(new string[] {
string.Format("{0} {1} = {5}global::Java.Lang.Object.GetObject<{4}> ({2}, {3});",
opt.GetOutputName(FullName),
opt.GetSafeIdentifier(var_name),
opt.GetSafeIdentifier(SymbolTable.GetNativeName(var_name)),
owned ? "JniHandleOwnership.TransferLocalRef" : "JniHandleOwnership.DoNotTransfer",
opt.GetOutputName(rgm != null ? (rgm.GetGenericJavaObjectTypeOverride() ?? FullName) : FullName),
rgm != null ? "(" + opt.GetOutputName(FullName) + ")" : string.Empty)
});
}
public string[] PreCall(CodeGenerationOptions opt, string var_name)
{
string managed_name = opt.GetSafeIdentifier(var_name);
string native_name = opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name));
if (opt.CodeGenerationTarget == CodeGenerationTarget.JavaInterop1)
{
return(new[] {
$"var {native_name} = global::Java.Interop.JniEnvironment.Strings.NewString ({managed_name});",
});
}
return(new[] {
$"IntPtr {native_name} = JNIEnv.NewString ({managed_name});",
});
}
public string[] PostCallback(CodeGenerationOptions opt, string var_name)
{
string managed_name = opt.GetSafeIdentifier(var_name);
string native_name = opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name));
if (opt.CodeGenerationTarget == CodeGenerationTarget.JavaInterop1)
{
return(new string[] {
$"throw new NotSupportedException (\"ArraySymbol.PostCallback\");",
});
}
return(new[] {
$"if ({managed_name} != null)",
$"\tJNIEnv.CopyArray ({managed_name}, {native_name});",
});
}
public string[] PostCall(CodeGenerationOptions opt, string var_name)
{
return(new string[] {
string.Format("JNIEnv.DeleteLocalRef ({0});",
opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name))),
});
}
public string FromNative(CodeGenerationOptions opt, string varname, bool owned)
{
return(String.Format("{0}.FromJniHandle ({1}, {2})",
GetManagedTypeName(opt),
opt.GetSafeIdentifier(varname),
owned ? "JniHandleOwnership.TransferLocalRef" : "JniHandleOwnership.DoNotTransfer"));
}
public string[] PreCall(CodeGenerationOptions opt, string var_name)
{
return(new string[] {
string.Format("IntPtr {0} = JNIEnv.ToLocalJniHandle ({1});",
opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name)), opt.GetSafeIdentifier(var_name)),
});
}
public string FromNative(CodeGenerationOptions opt, string varname, bool owned)
{
return(String.Format("global::Java.Util.InteroperableArrays.ToLocal{0} (ref {1}, {2})",
GetManagedTypeName(opt),
opt.GetSafeIdentifier(varname),
owned ? "JniObjectReferenceOptions.CopyAndDispose" : "JniObjectReferenceOptions.None"));
}
public string[] PostCallback(CodeGenerationOptions opt, string var_name)
{
string[] result = new string [2];
result [0] = String.Format("if ({0} != null)", opt.GetSafeIdentifier(var_name));
result [1] = String.Format("\tglobal::Java.Util.InteroperableArrays.ArrayCopy({0}, {1});", opt.GetSafeIdentifier(var_name), opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name)));
return(result);
}
public string[] PreCallback(CodeGenerationOptions opt, string var_name, bool owned)
{
return(new string[] {
string.Format("var {1} = global::Java.Lang.Object.GetObject<{0}> ({2}, {3});",
opt.GetOutputName(FullName),
var_name,
opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name)),
owned ? "JniHandleOwnership.TransferLocalRef" : "JniHandleOwnership.DoNotTransfer"),
});
}
public string[] PreCallback(CodeGenerationOptions opt, string var_name, bool owned)
{
return(new string[] {
string.Format("System.IO.Stream {0} = global::Android.Runtime.{1}Invoker.FromJniHandle ({2}, {3});",
var_name,
base_name,
opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name)),
owned ? "JniHandleOwnership.TransferLocalRef" : "JniHandleOwnership.DoNotTransfer"),
});
}
public string GetCallbackSignature(CodeGenerationOptions opt)
{
StringBuilder sb = new StringBuilder();
foreach (Parameter p in items)
{
sb.Append(", ");
sb.Append(p.NativeType);
sb.Append(" ");
sb.Append(opt.GetSafeIdentifier(p.UnsafeNativeName));
}
return(sb.ToString());
}
public string GetCall(CodeGenerationOptions opt)
{
StringBuilder sb = new StringBuilder();
foreach (Parameter p in items)
{
if (sb.Length > 0)
{
sb.Append(", ");
}
sb.Append(opt.GetSafeIdentifier(p.Name));
}
return(sb.ToString());
}
public string[] GetPreCallback(CodeGenerationOptions opt)
{
if (Type == NativeType)
{
return(new string [0]);
}
else if (NeedsPrep)
{
return(sym.PreCallback(opt, Name, false));
}
else
{
return new string[] { opt.GetOutputName(Type) + " " + opt.GetSafeIdentifier(Name) + " = " + FromNative(opt, false) + ";" }
};
}
public string GetGenericReturn(CodeGenerationOptions opt, string name, Dictionary <string, string> mappings)
{
string targetType = sym.GetGenericType(mappings);
if (string.IsNullOrEmpty(targetType))
{
return(name);
}
if (targetType == "string")
{
return(string.Format("{0}.ToString ()", name));
}
var rgm = opt.SymbolTable.Lookup(targetType) as IRequireGenericMarshal;
return(string.Format("global::Java.Interop.JavaObjectExtensions.JavaCast<{0}>({1})",
rgm != null ? (rgm.GetGenericJavaObjectTypeOverride() ?? sym.FullName) : sym.FullName,
opt.GetSafeIdentifier(rgm != null ? rgm.ToInteroperableJavaObject(name) : name)));
}
