public string[] PreCallback(CodeGenerationOptions opt, string var_name, bool owned)
{
return(new string[] { String.Format("global::Java.Lang.ICharSequence {0} = global::Java.Lang.Object.GetObject<global::Java.Lang.ICharSequence> ({1}, JniHandleOwnership.DoNotTransfer);", var_name, SymbolTable.GetNativeName(var_name)) });
}
public string[] PostCallback(CodeGenerationOptions opt, string var_name)
{
return(new string [0]);
}
public string[] PreCallback(CodeGenerationOptions opt, string var_name, bool owned)
{
return(new string[] { String.Format("var {0} = global::Android.Runtime.XmlPullParserReader.FromJniHandle ({1}, JniHandleOwnership.DoNotTransfer);", opt.GetSafeIdentifier(var_name), opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name))) });
}
public string FromNative(CodeGenerationOptions opt, string var_name, bool owned)
{
return(String.Format(opt.GetOutputName("Android.Runtime.XmlPullParserReader") + ".FromJniHandle ({0}, {1})", var_name, owned ? "JniHandleOwnership.TransferLocalRef" : "JniHandleOwnership.DoNotTransfer"));
}
public bool Validate(CodeGenerationOptions opt, GenericParameterDefinitionList type_params, CodeGeneratorContext context)
{
return(true);
}
public string FromNative (CodeGenerationOptions opt, string varname, bool owned)
{
return String.Format ("({0}) {1}", opt.GetOutputName (type), varname);
}
public string[] PreCallback (CodeGenerationOptions opt, string var_name, bool owned)
{
throw new NotSupportedException (string.Format ("{0} does not support PreCallback", this.GetType ().Name));
}
public void Generate(GenBase gen, StreamWriter sw, string indent, CodeGenerationOptions opt)
{
Generate(gen, sw, indent, opt, true, false);
}
public void Generate(GenBase gen, StreamWriter sw, string indent, CodeGenerationOptions opt, bool with_callbacks, bool force_override)
{
// <TechnicalDebt>
// This is a special workaround for AdapterView inheritance.
// (How it is special? They have hand-written bindings AND brings generic
// version of AdapterView<T> in the inheritance, also added by metadata!)
//
// They are on top of fragile hand-bound code, and when we are making changes
// in generator, they bite. Since we are not going to bring API breakage
// right now, we need special workarounds to get things working.
//
// So far, what we need here is to have AbsSpinner.Adapter compile.
//
// > platforms/*/src/generated/Android.Widget.AbsSpinner.cs(156,56): error CS0533:
// > `Android.Widget.AbsSpinner.Adapter' hides inherited abstract member
// > `Android.Widget.AdapterView<Android.Widget.ISpinnerAdapter>.Adapter
//
// It is because the AdapterView<T>.Adapter is hand-bound and cannot be
// detected by generator!
//
// So, we explicitly treat it as a special-case.
//
// Then, Spinner, ListView and GridView instantiate them, so they are also special cases.
// </TechnicalDebt>
if (Name == "Adapter" &&
(Getter.DeclaringType.BaseGen.FullName == "Android.Widget.AdapterView" ||
Getter.DeclaringType.BaseGen.BaseGen != null && Getter.DeclaringType.BaseGen.BaseGen.FullName == "Android.Widget.AdapterView"))
{
force_override = true;
}
// ... and the above breaks generator tests...
if (Name == "Adapter" &&
(Getter.DeclaringType.BaseGen.FullName == "Xamarin.Test.AdapterView" ||
Getter.DeclaringType.BaseGen.BaseGen != null && Getter.DeclaringType.BaseGen.BaseGen.FullName == "Xamarin.Test.AdapterView"))
{
force_override = true;
}
string decl_name = AdjustedName;
string needNew = gen.RequiresNew(decl_name) ? " new" : "";
string virtual_override = String.Empty;
bool is_virtual = Getter.IsVirtual && (Setter == null || Setter.IsVirtual);
if (with_callbacks && is_virtual)
{
virtual_override = needNew + " virtual";
opt.CodeGenerator.WriteMethodCallback(Getter, sw, indent, opt, gen, AdjustedName);
}
if (with_callbacks && is_virtual && Setter != null)
{
virtual_override = needNew + " virtual";
opt.CodeGenerator.WriteMethodCallback(Setter, sw, indent, opt, gen, AdjustedName);
}
virtual_override = force_override ? " override" : virtual_override;
if ((Getter ?? Setter).IsStatic)
{
virtual_override = " static";
}
// It should be using AdjustedName instead of Name, but ICharSequence ("Formatted") properties are not caught by this...
else if (gen.BaseSymbol != null && gen.BaseSymbol.GetPropertyByName(Name, true) != null)
{
virtual_override = " override";
}
opt.CodeGenerator.WriteMethodIdField(Getter, sw, indent, opt);
if (Setter != null)
{
opt.CodeGenerator.WriteMethodIdField(Setter, sw, indent, opt);
}
string visibility = Getter.IsAbstract && Getter.RetVal.IsGeneric ? "protected" : (Setter ?? Getter).Visibility;
// Unlike [Register], mcs does not allow applying [Obsolete] on property accessors, so we can apply them only under limited condition...
if (Getter.Deprecated != null && (Setter == null || Setter.Deprecated != null))
{
sw.WriteLine("{0}[Obsolete (@\"{1}\")]", indent, Getter.Deprecated.Replace("\"", "\"\"").Trim() + (Setter != null && Setter.Deprecated != Getter.Deprecated ? " " + Setter.Deprecated.Replace("\"", "\"\"").Trim() : null));
}
opt.CodeGenerator.WriteMethodCustomAttributes(Getter, sw, indent);
sw.WriteLine("{0}{1}{2} unsafe {3} {4} {{", indent, visibility, virtual_override, opt.GetOutputName(Getter.ReturnType), decl_name);
if (gen.IsGeneratable)
{
sw.WriteLine("{0}\t// Metadata.xml XPath method reference: path=\"{1}/method[@name='{2}'{3}]\"", indent, gen.MetadataXPathReference, Getter.JavaName, Getter.Parameters.GetMethodXPathPredicate());
}
sw.WriteLine("{0}\t[Register (\"{1}\", \"{2}\", \"{3}\"{4})]", indent, Getter.JavaName, Getter.JniSignature, Getter.ConnectorName, Getter.AdditionalAttributeString());
sw.WriteLine("{0}\tget {{", indent);
opt.CodeGenerator.WriteMethodBody(Getter, sw, indent + "\t\t", opt);
sw.WriteLine("{0}\t}}", indent);
if (Setter != null)
{
if (gen.IsGeneratable)
{
sw.WriteLine("{0}\t// Metadata.xml XPath method reference: path=\"{1}/method[@name='{2}'{3}]\"", indent, gen.MetadataXPathReference, Setter.JavaName, Setter.Parameters.GetMethodXPathPredicate());
}
opt.CodeGenerator.WriteMethodCustomAttributes(Setter, sw, indent);
sw.WriteLine("{0}\t[Register (\"{1}\", \"{2}\", \"{3}\"{4})]", indent, Setter.JavaName, Setter.JniSignature, Setter.ConnectorName, Setter.AdditionalAttributeString());
sw.WriteLine("{0}\tset {{", indent);
string pname = Setter.Parameters [0].Name;
Setter.Parameters [0].Name = "value";
opt.CodeGenerator.WriteMethodBody(Setter, sw, indent + "\t\t", opt);
Setter.Parameters [0].Name = pname;
sw.WriteLine("{0}\t}}", indent);
}
else if (GenerateDispatchingSetter)
{
sw.WriteLine("{0}// This is a dispatching setter", indent + "\t");
sw.WriteLine("{0}set {{ Set{1} (value); }}", indent + "\t", Name);
}
sw.WriteLine("{0}}}", indent);
sw.WriteLine();
if (Type.StartsWith("Java.Lang.ICharSequence") && virtual_override != " override")
{
GenerateStringVariant(sw, indent);
}
}
public string Call(CodeGenerationOptions opt, string var_name) => opt.GetSafeIdentifier(var_name);
public abstract string FromNative(CodeGenerationOptions opt, string varname, bool owned);
public bool Validate(CodeGenerationOptions opt, GenericParameterDefinitionList type_params, CodeGeneratorContext context)
{
return(parms == null || parms.Validate(opt, type_params, context));
}
public string ToNative(CodeGenerationOptions opt, string varname, Dictionary <string, string> mappings = null)
{
return(string.Format("{0}.ToLocalJniHandle ({1})",
GetManagedTypeName(opt),
opt.GetSafeIdentifier(varname)));
}
public string[] PreCall(CodeGenerationOptions opt, string var_name)
{
return(new string[] { String.Format("IntPtr {0} = CharSequence.ToLocalJniHandle ({1});", opt.GetSafeIdentifier(SymbolTable.GetNativeName(var_name)), opt.GetSafeIdentifier(var_name)) });
}
public string FromNative(CodeGenerationOptions opt, string varname, bool owned)
{
return(String.Format("({0}) global::Java.Lang.Object.GetObject<{3}> ({1}, {2})", type, varname, owned ? "JniHandleOwnership.TransferLocalRef" : "JniHandleOwnership.DoNotTransfer", opt.GetOutputName(FullName)));
}
public void GenerateCallbacks(StreamWriter sw, string indent, CodeGenerationOptions opt, GenBase gen)
{
GenerateCallbacks(sw, indent, opt, gen, AdjustedName);
}
public JavaInteropCodeGenerator(TextWriter writer, CodeGenerationOptions options) : base(writer, options)
{
}
public override string ToNative(CodeGenerationOptions opt, string varname, Dictionary <string, string> mappings = null)
{
return(String.Format("JNIEnv.ToLocalJniHandle ({0})", varname));
}
public string ToNative (CodeGenerationOptions opt, string varname, Dictionary<string, string> mappings = null)
{
return "(int) " + varname;
}
public override void Generate(StreamWriter sw, string indent, CodeGenerationOptions opt, GenerationInfo gen_info)
{
opt.ContextTypes.Push(this);
opt.ContextGeneratedMethods = new List <Method> ();
gen_info.TypeRegistrations.Add(new KeyValuePair <string, string>(RawJniName, AssemblyQualifiedName));
bool is_enum = base_symbol != null && base_symbol.FullName == "Java.Lang.Enum";
if (is_enum)
{
gen_info.Enums.Add(RawJniName.Replace('/', '.') + ":" + Namespace + ":" + JavaSimpleName);
}
StringBuilder sb = new StringBuilder();
foreach (ISymbol isym in Interfaces)
{
GenericSymbol gs = isym as GenericSymbol;
InterfaceGen gen = (gs == null ? isym : gs.Gen) as InterfaceGen;
if (gen != null && gen.IsConstSugar)
{
continue;
}
if (sb.Length > 0)
{
sb.Append(", ");
}
sb.Append(opt.GetOutputName(isym.FullName));
}
string obj_type = null;
if (base_symbol != null)
{
GenericSymbol gs = base_symbol as GenericSymbol;
obj_type = gs != null && gs.IsConcrete ? gs.GetGenericType(null) : opt.GetOutputName(base_symbol.FullName);
}
sw.WriteLine("{0}// Metadata.xml XPath class reference: path=\"{1}\"", indent, MetadataXPathReference);
if (this.IsDeprecated)
{
sw.WriteLine("{0}[ObsoleteAttribute (@\"{1}\")]", indent, this.DeprecatedComment);
}
sw.WriteLine("{0}[global::Android.Runtime.Register (\"{1}\", DoNotGenerateAcw=true{2})]", indent, RawJniName, this.AdditionalAttributeString());
if (this.TypeParameters != null && this.TypeParameters.Any())
{
sw.WriteLine("{0}{1}", indent, TypeParameters.ToGeneratedAttributeString());
}
string inherits = "";
if (inherits_object && obj_type != null)
{
inherits = ": " + obj_type;
}
if (sb.Length > 0)
{
if (string.IsNullOrEmpty(inherits))
{
inherits = ": ";
}
else
{
inherits += ", ";
}
}
sw.WriteLine("{0}{1} {2}{3}{4}partial class {5} {6}{7} {{",
indent,
Visibility,
needs_new ? "new " : String.Empty,
IsAbstract ? "abstract " : String.Empty,
IsFinal ? "sealed " : String.Empty,
Name,
inherits,
sb.ToString());
sw.WriteLine();
var seen = new HashSet <string> ();
GenFields(sw, indent + "\t", opt, seen);
bool haveNested = false;
foreach (var iface in GetAllImplementedInterfaces()
.Except(BaseGen == null
? new InterfaceGen[0]
: BaseGen.GetAllImplementedInterfaces())
.Where(i => i.Fields.Count > 0))
{
if (!haveNested)
{
sw.WriteLine();
sw.WriteLine("{0}\tpublic static class InterfaceConsts {{", indent);
haveNested = true;
}
sw.WriteLine();
sw.WriteLine("{0}\t\t// The following are fields from: {1}", indent, iface.JavaName);
iface.GenFields(sw, indent + "\t\t", opt, seen);
}
if (haveNested)
{
sw.WriteLine("{0}\t}}\n", indent);
}
foreach (GenBase nest in NestedTypes)
{
if (BaseGen != null && BaseGen.ContainsNestedType(nest))
{
if (nest is ClassGen)
{
(nest as ClassGen).needs_new = true;
}
}
nest.Generate(sw, indent + "\t", opt, gen_info);
sw.WriteLine();
}
bool requireNew = InheritsObject;
if (!requireNew)
{
for (var bg = BaseGen; bg != null && bg is XmlClassGen; bg = bg.BaseGen)
{
if (bg.InheritsObject)
{
requireNew = true;
break;
}
}
}
opt.CodeGenerator.WriteClassHandle(this, sw, indent, opt, requireNew);
GenConstructors(sw, indent + "\t", opt);
GenProperties(sw, indent + "\t", opt);
GenMethods(sw, indent + "\t", opt);
if (IsAbstract)
{
GenerateAbstractMembers(sw, indent + "\t", opt);
}
bool is_char_seq = false;
foreach (ISymbol isym in Interfaces)
{
if (isym is GenericSymbol)
{
GenericSymbol gs = isym as GenericSymbol;
if (gs.IsConcrete)
{
// FIXME: not sure if excluding default methods is a valid idea...
foreach (Method m in gs.Gen.Methods.Where(m => !m.IsInterfaceDefaultMethod && !m.IsStatic))
{
if (m.IsGeneric)
{
m.GenerateExplicitIface(sw, indent + "\t", opt, gs);
}
}
}
}
else if (isym.FullName == "Java.Lang.ICharSequence")
{
is_char_seq = true;
}
}
if (is_char_seq)
{
GenCharSequenceEnumerator(sw, indent + "\t", opt);
}
sw.WriteLine(indent + "}");
if (!AssemblyQualifiedName.Contains('/'))
{
foreach (InterfaceExtensionInfo nestedIface in GetNestedInterfaceTypes())
{
nestedIface.Type.GenerateExtensionsDeclaration(sw, indent, opt, nestedIface.DeclaringType);
}
}
if (IsAbstract)
{
sw.WriteLine();
GenerateInvoker(sw, indent, opt);
}
opt.ContextGeneratedMethods.Clear();
opt.ContextTypes.Pop();
}
public string[] PostCall (CodeGenerationOptions opt, string var_name)
{
throw new NotSupportedException (string.Format ("{0} does not support PostCall", this.GetType ().Name));
}
void GenerateInvoker(StreamWriter sw, IEnumerable <Property> properties, string indent, CodeGenerationOptions opt, HashSet <string> members)
{
foreach (Property prop in properties)
{
if (members.Contains(prop.Name))
{
continue;
}
members.Add(prop.Name);
if ((prop.Getter != null && !prop.Getter.IsAbstract) ||
(prop.Setter != null && !prop.Setter.IsAbstract))
{
continue;
}
prop.Generate(this, sw, indent, opt, false, true);
}
}
public string ToNative(CodeGenerationOptions opt, string var_name, Dictionary <string, string> mappings = null)
{
return(String.Format("global::Android.Runtime.XmlReaderPullParser.ToLocalJniHandle ({0})", var_name));
}
void GenerateInvoker(StreamWriter sw, IEnumerable <Method> methods, string indent, CodeGenerationOptions opt, HashSet <string> members, InterfaceGen gen)
{
foreach (Method m in methods)
{
string sig = m.GetSignature();
if (members.Contains(sig))
{
continue;
}
members.Add(sig);
if (!m.IsAbstract)
{
continue;
}
if (IsExplicitlyImplementedMethod(sig))
{
// sw.WriteLine ("// This invoker explicitly implements this method");
m.GenerateExplicitInterfaceInvoker(sw, indent, opt, gen);
}
else
{
// sw.WriteLine ("// This invoker overrides {0} method", gen.FullName);
m.IsOverride = true;
m.Generate(sw, indent, opt, this, false);
m.IsOverride = false;
}
}
}
public string Call(CodeGenerationOptions opt, string var_name)
{
return(opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name)));
}
public static void GenerateTypeRegistrations(CodeGenerationOptions opt, GenerationInfo gen_info)
{
StreamWriter sw = gen_info.Writer = gen_info.OpenStream(opt.GetFileName("Java.Interop.__TypeRegistrations"));
Dictionary <string, List <KeyValuePair <string, string> > > mapping = new Dictionary <string, List <KeyValuePair <string, string> > >();
foreach (KeyValuePair <string, string> reg in gen_info.TypeRegistrations)
{
int ls = reg.Key.LastIndexOf('/');
string package = ls >= 0 ? reg.Key.Substring(0, ls) : "";
if (JavaNativeTypeManager.ToCliType(reg.Key) == reg.Value)
{
continue;
}
List <KeyValuePair <string, string> > v;
if (!mapping.TryGetValue(package, out v))
{
mapping.Add(package, v = new List <KeyValuePair <string, string> >());
}
v.Add(new KeyValuePair <string, string>(reg.Key, reg.Value));
}
sw.WriteLine("using System;");
sw.WriteLine("using System.Collections.Generic;");
sw.WriteLine("using Android.Runtime;");
sw.WriteLine();
sw.WriteLine("namespace Java.Interop {");
sw.WriteLine();
sw.WriteLine("\tpartial class __TypeRegistrations {");
sw.WriteLine();
sw.WriteLine("\t\tpublic static void RegisterPackages ()");
sw.WriteLine("\t\t{");
sw.WriteLine("#if MONODROID_TIMING");
sw.WriteLine("\t\t\tvar start = DateTime.Now;");
sw.WriteLine("\t\t\tAndroid.Util.Log.Info (\"MonoDroid-Timing\", \"RegisterPackages start: \" + (start - new DateTime (1970, 1, 1)).TotalMilliseconds);");
sw.WriteLine("#endif // def MONODROID_TIMING");
sw.WriteLine("\t\t\tJava.Interop.TypeManager.RegisterPackages (");
sw.WriteLine("\t\t\t\t\tnew string[]{");
foreach (KeyValuePair <string, List <KeyValuePair <string, string> > > e in mapping)
{
sw.WriteLine("\t\t\t\t\t\t\"{0}\",", e.Key);
}
sw.WriteLine("\t\t\t\t\t},");
sw.WriteLine("\t\t\t\t\tnew Converter<string, Type>[]{");
foreach (KeyValuePair <string, List <KeyValuePair <string, string> > > e in mapping)
{
sw.WriteLine("\t\t\t\t\t\tlookup_{0}_package,", e.Key.Replace('/', '_'));
}
sw.WriteLine("\t\t\t\t\t});");
sw.WriteLine("#if MONODROID_TIMING");
sw.WriteLine("\t\t\tvar end = DateTime.Now;");
sw.WriteLine("\t\t\tAndroid.Util.Log.Info (\"MonoDroid-Timing\", \"RegisterPackages time: \" + (end - new DateTime (1970, 1, 1)).TotalMilliseconds + \" [elapsed: \" + (end - start).TotalMilliseconds + \" ms]\");");
sw.WriteLine("#endif // def MONODROID_TIMING");
sw.WriteLine("\t\t}");
sw.WriteLine();
sw.WriteLine("\t\tstatic Type Lookup (string[] mappings, string javaType)");
sw.WriteLine("\t\t{");
sw.WriteLine("\t\t\tstring managedType = Java.Interop.TypeManager.LookupTypeMapping (mappings, javaType);");
sw.WriteLine("\t\t\tif (managedType == null)");
sw.WriteLine("\t\t\t\treturn null;");
sw.WriteLine("\t\t\treturn Type.GetType (managedType);");
sw.WriteLine("\t\t}");
foreach (KeyValuePair <string, List <KeyValuePair <string, string> > > map in mapping)
{
sw.WriteLine();
string package = map.Key.Replace('/', '_');
sw.WriteLine("\t\tstatic string[] package_{0}_mappings;", package);
sw.WriteLine("\t\tstatic Type lookup_{0}_package (string klass)", package);
sw.WriteLine("\t\t{");
sw.WriteLine("\t\t\tif (package_{0}_mappings == null) {{", package);
sw.WriteLine("\t\t\t\tpackage_{0}_mappings = new string[]{{", package);
map.Value.Sort((a, b) => a.Key.CompareTo(b.Key));
foreach (KeyValuePair <string, string> t in map.Value)
{
sw.WriteLine("\t\t\t\t\t\"{0}:{1}\",", t.Key, t.Value);
}
sw.WriteLine("\t\t\t\t};");
sw.WriteLine("\t\t\t}");
sw.WriteLine("");
sw.WriteLine("\t\t\treturn Lookup (package_{0}_mappings, klass);", package);
sw.WriteLine("\t\t}");
}
sw.WriteLine("\t}");
sw.WriteLine("}");
sw.Close();
gen_info.Writer = null;
}
public string[] PostCall(CodeGenerationOptions opt, string var_name)
{
return(new string [] {
string.Format("JNIEnv.DeleteLocalRef ({0});", opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name))),
});
}
public string Call(CodeGenerationOptions opt, string var_name)
{
return(opt.GetSafeIdentifier(SymbolTable.GetNativeName(var_name)));
}
public string[] PreCall(CodeGenerationOptions opt, string var_name)
{
return(new string[] { String.Format("IntPtr {0} = global::Android.Runtime.XmlReaderPullParser.ToLocalJniHandle ({1});", opt.GetSafeIdentifier(TypeNameUtilities.GetNativeName(var_name)), opt.GetSafeIdentifier(var_name)) });
}
public string ToNative(CodeGenerationOptions opt, string var_name, Dictionary <string, string> mappings = null)
{
return(String.Format("CharSequence.ToLocalJniHandle ({0})", var_name));
}