From d20453b48481c709453707d3293a46360029c752 Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Mon, 9 Jul 2018 23:57:19 +0900 Subject: [PATCH 01/18] [msbuild] Add support for C# 8 default interface methods (DIMs) step 1. 1) You have to manually provide CscToolPath MSBuild property, unless you install xamarin.android.csc.dim package. 2) You have to explicitly specify AndroidEnableDefaultInterfaceMethods MSBuild property as True. 3) You have to explicitly specify LangVersion MSBuild property as "latest". When C# 8.0 becomes stable, 1) and 3) will become unnecessary. Then we should make changes to 2) as default. --- .../Tasks/Generator.cs | 5 ++ .../BindingBuildTest.cs | 54 +++++++++++++++++++ .../Xamarin.Android.Bindings.targets | 1 + 3 files changed, 60 insertions(+) diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/Generator.cs b/src/Xamarin.Android.Build.Tasks/Tasks/Generator.cs index e3555270254..9fb962f1ca3 100644 --- a/src/Xamarin.Android.Build.Tasks/Tasks/Generator.cs +++ b/src/Xamarin.Android.Build.Tasks/Tasks/Generator.cs @@ -41,6 +41,8 @@ public class BindingsGenerator : AndroidToolTask public bool UseShortFileNames { get; set; } + public bool EnableDefaultInterfaceMethods { get; set; } + // apart from ReferencedManagedLibraries we need it to find mscorlib.dll. [Required] public string MonoAndroidFrameworkDirectories { get; set; } @@ -64,6 +66,7 @@ public override bool Execute () Log.LogDebugMessage (" AssemblyName: {0}", AssemblyName); Log.LogDebugMessage (" AndroidApiLevel: {0}", AndroidApiLevel); Log.LogDebugMessage (" UseShortFileNames: {0}", UseShortFileNames); + Log.LogDebugMessage (" EnableDefaultInterfaceMethods: {0}", EnableDefaultInterfaceMethods); Log.LogDebugTaskItems (" TransformFiles:", TransformFiles); Log.LogDebugTaskItems (" ReferencedManagedLibraries:", ReferencedManagedLibraries); Log.LogDebugTaskItems (" AnnotationsZipFiles:", AnnotationsZipFiles); @@ -119,6 +122,8 @@ protected override string GenerateCommandLineCommands () cmd.AppendSwitchIfNotNull ("--enumdir=", EnumDirectory); cmd.AppendSwitchIfNotNull ("--enummetadata=", EnumMetadataDirectory); cmd.AppendSwitchIfNotNull ("--assembly=", AssemblyName); + if (EnableDefaultInterfaceMethods) + cmd.AppendSwitch ("--default-interface-methods"); if (!NoStdlib) { string fxpath = MonoAndroidFrameworkDirectories.Split (';').First (p => new DirectoryInfo (p).GetFiles ("mscorlib.dll").Any ()); diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BindingBuildTest.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BindingBuildTest.cs index ff18627c040..dd08038bc48 100644 --- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BindingBuildTest.cs +++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BindingBuildTest.cs @@ -446,5 +446,59 @@ public String greet (String name, java.util.Date date) Assert.IsTrue (xml.Contains (" - name to display."), "missing doc"); } } + + [Test] + [TestCaseSource ("ClassParseOptions")] + public void BindDefaultInterfaceMethods (string classParser) + { + var proj = new XamarinAndroidBindingProject () { + IsRelease = true, + }; + proj.Packages.Add (new Package { Id = "xamarin.android.csc.dim", Version = "0.1.2" }); + // The sources for the .jar is in the jar itself. + string classesJarBase64 = @" +UEsDBBQACAgIANWk6UwAAAAAAAAAAAAAAAAJAAQATUVUQS1JTkYv/soAAAMAUEsHCAAAAAACAAAAAAA +AAFBLAwQUAAgICADVpOlMAAAAAAAAAAAAAAAAFAAAAE1FVEEtSU5GL01BTklGRVNULk1G803My0xLLS +7RDUstKs7Mz7NSMNQz4OVyLkpNLElN0XWqBAlY6BnEG5obKmj4FyUm56QqOOcXFeQXJZYA1WvycvFyA +QBQSwcIFGFrLUQAAABFAAAAUEsDBAoAAAgAAK2k6UwAAAAAAAAAAAAAAAAEAAAAY29tL1BLAwQKAAAI +AACtpOlMAAAAAAAAAAAAAAAADAAAAGNvbS94YW1hcmluL1BLAwQKAAAIAACwpOlMAAAAAAAAAAAAAAA +AEQAAAGNvbS94YW1hcmluL3Rlc3QvUEsDBBQACAgIAJmk6UwAAAAAAAAAAAAAAAAuAAAAY29tL3hhbW +FyaW4vdGVzdC9EZWZhdWx0SW50ZXJmYWNlTWV0aG9kcy5jbGFzc3WOvU7DMBSFjxsnKeWnXUE8QLrgh +ScAhBSJnwHE7qQ3JVUSC8dGFc/EwsrAA/BQiOuqLKnw8Pn4+LuWv38+vwCcY5biKMVUIKqMYWbzXEBe +mgUJTG/qju58W5B91EXDTbIkd6HtX3jj0G+DzPL5E28v3q8FJg/G25Ku6zB1ekWV9o3LO0e20iXdkns +2i/5spV+1QFaaVq11q23dKUe9U//4ArMwoRrdLdV9saLSJQICI4QVc4ogmTGfThBugFH0zuR/MpNNE7 +x015NDL3C868VDL2XuYbL1joMTjI+BNpYC+/xcaA820uEvUEsHCIw1aijpAAAAhQEAAFBLAwQUAAgIC +ACYpOlMAAAAAAAAAAAAAAAAHAAAAERlZmF1bHRJbnRlcmZhY2VNZXRob2RzLmphdmF1zLEOwiAQBuCd +p7hRl0Zd2YyLgw9xwlGJFCocTWPTdxdSHarxxv///utR3bElUKFrRuwwWt8wJZZC9PnqrALrmaJBRXA +ig9nx+RNciG9BJzEJKKeXtnowIcBmCxNE4hw97CTMP6glPmJcuf1f91y5w7cbgtWQ3rCOBnSZymJhNX +nkPJYnUsziBVBLBwgzfz2miQAAAPUAAABQSwECFAAUAAgICADVpOlMAAAAAAIAAAAAAAAACQAEAAAAA +AAAAAAAAAAAAAAATUVUQS1JTkYv/soAAFBLAQIUABQACAgIANWk6UwUYWstRAAAAEUAAAAUAAAAAAAA +AAAAAAAAAD0AAABNRVRBLUlORi9NQU5JRkVTVC5NRlBLAQIKAAoAAAgAAK2k6UwAAAAAAAAAAAAAAAA +EAAAAAAAAAAAAAAAAAMMAAABjb20vUEsBAgoACgAACAAAraTpTAAAAAAAAAAAAAAAAAwAAAAAAAAAAA +AAAAAA5QAAAGNvbS94YW1hcmluL1BLAQIKAAoAAAgAALCk6UwAAAAAAAAAAAAAAAARAAAAAAAAAAAAA +AAAAA8BAABjb20veGFtYXJpbi90ZXN0L1BLAQIUABQACAgIAJmk6UyMNWoo6QAAAIUBAAAuAAAAAAAA +AAAAAAAAAD4BAABjb20veGFtYXJpbi90ZXN0L0RlZmF1bHRJbnRlcmZhY2VNZXRob2RzLmNsYXNzUEs +BAhQAFAAICAgAmKTpTDN/PaaJAAAA9QAAABwAAAAAAAAAAAAAAAAAgwIAAERlZmF1bHRJbnRlcmZhY2 +VNZXRob2RzLmphdmFQSwUGAAAAAAcABwDOAQAAVgMAAAAA +"; + proj.Jars.Add (new AndroidItem.EmbeddedJar ("dim.jar") { + BinaryContent = () => Convert.FromBase64String (classesJarBase64) + }); + proj.AndroidClassParser = classParser; + proj.SetProperty ("CscToolPath", "$(MSBuildThisFileDirectory)\\..\\packages\\xamarin.android.csc.dim.0.1.2\\tools"); + proj.SetProperty ("AndroidEnableDefaultInterfaceMethods", "True"); + proj.SetProperty ("LangVersion", "latest"); + using (var b = CreateDllBuilder (Path.Combine ("temp", TestName), false, false)) { + proj.NuGetRestore (b.ProjectDirectory); + Assert.IsTrue (b.Build (proj), "Build should have succeeded."); + string asmpath = Path.GetFullPath (Path.Combine (Path.GetDirectoryName (new Uri (GetType ().Assembly.CodeBase).LocalPath), b.ProjectDirectory, b.Output.OutputPath, (proj.AssemblyName ?? proj.ProjectName) + ".dll")); + Assert.IsTrue (File.Exists (asmpath), "assembly does not exist"); + var cs = b.Output.GetIntermediaryAsText (Path.Combine ("generated", "src", "Com.Xamarin.Test.IDefaultInterfaceMethods.cs")); + Assert.IsTrue (cs.Contains ("int Quux ();"), "Quux not generated."); + Assert.IsTrue (cs.Contains ("virtual unsafe int Foo ()"), "Foo not generated."); + Assert.IsTrue (cs.Contains ("virtual unsafe int Bar {"), "Bar not generated."); + Assert.IsTrue (cs.Contains ("set {"), "(Baz) setter not generated."); + } + } } } diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Bindings.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Bindings.targets index 2fdb17639ba..efb301d68ac 100755 --- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Bindings.targets +++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Bindings.targets @@ -489,6 +489,7 @@ Copyright (C) 2012 Xamarin Inc. All rights reserved. ToolPath="$(MonoAndroidToolsDirectory)" ToolExe="$(BindingsGeneratorToolExe)" UseShortFileNames="$(UseShortGeneratorFileNames)" + EnableDefaultInterfaceMethods="$(AndroidEnableDefaultInterfaceMethods)" /> From c5618e8286b5bcbdba33cbb8681c6f03fcfc3e21 Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Tue, 10 Jul 2018 17:55:04 +0900 Subject: [PATCH 02/18] Add tests for default interface method bindings. They fail so far, because generator is not generating expected code yet. --- Xamarin.Android-Tests.sln | 14 ++++ .../Additions/AboutAdditions.txt | 48 +++++++++++ .../Jars/AboutJars.txt | 36 +++++++++ .../Jars/DefaultInterfaceMethods.java | 10 +++ .../Jars/ImplementedClass.java | 6 ++ .../Properties/AssemblyInfo.cs | 27 +++++++ .../Transforms/EnumFields.xml | 19 +++++ .../Transforms/EnumMethods.xml | 19 +++++ .../Transforms/Metadata.xml | 10 +++ ...Android.DefaultInterfaceMethods-Lib.csproj | 67 ++++++++++++++++ .../packages.config | 5 ++ .../Assets/AboutAssets.txt | 19 +++++ .../MainActivity.cs | 23 ++++++ .../Properties/AndroidManifest.xml | 5 ++ .../Properties/AssemblyInfo.cs | 27 +++++++ .../Resources/AboutResources.txt | 44 ++++++++++ .../Resources/mipmap-hdpi/Icon.png | Bin 0 -> 2201 bytes .../Resources/mipmap-mdpi/Icon.png | Bin 0 -> 1410 bytes .../Resources/mipmap-xhdpi/Icon.png | Bin 0 -> 3237 bytes .../Resources/mipmap-xxhdpi/Icon.png | Bin 0 -> 5414 bytes .../Resources/mipmap-xxxhdpi/Icon.png | Bin 0 -> 7825 bytes .../TestsSample.cs | 26 ++++++ ...droid.DefaultInterfaceMethods-Tests.csproj | 75 ++++++++++++++++++ .../packages.config | 4 + 24 files changed, 484 insertions(+) create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Additions/AboutAdditions.txt create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Jars/AboutJars.txt create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Jars/DefaultInterfaceMethods.java create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Jars/ImplementedClass.java create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Properties/AssemblyInfo.cs create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Transforms/EnumFields.xml create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Transforms/EnumMethods.xml create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Transforms/Metadata.xml create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/packages.config create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Assets/AboutAssets.txt create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/MainActivity.cs create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Properties/AndroidManifest.xml create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Properties/AssemblyInfo.cs create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/AboutResources.txt create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/mipmap-hdpi/Icon.png create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/mipmap-mdpi/Icon.png create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/mipmap-xhdpi/Icon.png create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/mipmap-xxhdpi/Icon.png create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/mipmap-xxxhdpi/Icon.png create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/TestsSample.cs create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Xamarin.Android.DefaultInterfaceMethods-Tests.csproj create mode 100644 tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/packages.config diff --git a/Xamarin.Android-Tests.sln b/Xamarin.Android-Tests.sln index 308a55fd1eb..31bb7178a37 100644 --- a/Xamarin.Android-Tests.sln +++ b/Xamarin.Android-Tests.sln @@ -76,6 +76,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Performance-Tests", "Perfor EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "timing", "build-tools\timing\timing.csproj", "{37CAA28C-40BE-4253-BA68-CC5D7316A617}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Xamarin.Android.DefaultInterfaceMethods-Tests", "tests\CodeGen-Binding\Xamarin.Android.DefaultInterfaceMethods-Tests\Xamarin.Android.DefaultInterfaceMethods-Tests.csproj", "{80E5171A-56DF-48AC-8AD9-65028319C1B8}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Xamarin.Android.DefaultInterfaceMethods-Lib", "tests\CodeGen-Binding\Xamarin.Android.DefaultInterfaceMethods-Lib\Xamarin.Android.DefaultInterfaceMethods-Lib.csproj", "{E2F0F78B-6088-4282-A49C-122EE28611FF}" +EndProject Global GlobalSection(SharedMSBuildProjectFiles) = preSolution tests\Xamarin.Forms-Performance-Integration\Xamarin.Forms.Performance.Integration.projitems*{195be9c2-1f91-40dc-bd6d-de860bf083fb}*SharedItemsImports = 13 @@ -194,6 +198,14 @@ Global {37CAA28C-40BE-4253-BA68-CC5D7316A617}.Debug|Any CPU.Build.0 = Debug|Any CPU {37CAA28C-40BE-4253-BA68-CC5D7316A617}.Release|Any CPU.ActiveCfg = Release|Any CPU {37CAA28C-40BE-4253-BA68-CC5D7316A617}.Release|Any CPU.Build.0 = Release|Any CPU + {80E5171A-56DF-48AC-8AD9-65028319C1B8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {80E5171A-56DF-48AC-8AD9-65028319C1B8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {80E5171A-56DF-48AC-8AD9-65028319C1B8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {80E5171A-56DF-48AC-8AD9-65028319C1B8}.Release|Any CPU.Build.0 = Release|Any CPU + {E2F0F78B-6088-4282-A49C-122EE28611FF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E2F0F78B-6088-4282-A49C-122EE28611FF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E2F0F78B-6088-4282-A49C-122EE28611FF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E2F0F78B-6088-4282-A49C-122EE28611FF}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -225,6 +237,8 @@ Global {F4DAFD78-BE76-46C9-A1AD-85D8C91CD77B} = {9B63992C-2201-4BB0-BD00-D637B481A995} {2DD1EE75-6D8D-4653-A800-0A24367F7F38} = {9B63992C-2201-4BB0-BD00-D637B481A995} {37CAA28C-40BE-4253-BA68-CC5D7316A617} = {68B8E272-5B12-47AA-8923-550B9CE535C7} + {80E5171A-56DF-48AC-8AD9-65028319C1B8} = {2EFFECF5-1CCA-4005-AE62-1D6F01C88DF4} + {E2F0F78B-6088-4282-A49C-122EE28611FF} = {2EFFECF5-1CCA-4005-AE62-1D6F01C88DF4} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {8643CD20-B195-4919-8135-27549488237E} diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Additions/AboutAdditions.txt b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Additions/AboutAdditions.txt new file mode 100644 index 00000000000..c511f1d4ee1 --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Additions/AboutAdditions.txt @@ -0,0 +1,48 @@ +Additions allow you to add arbitrary C# to the generated classes +before they are compiled. This can be helpful for providing convenience +methods or adding pure C# classes. + +== Adding Methods to Generated Classes == + +Let's say the library being bound has a Rectangle class with a constructor +that takes an x and y position, and a width and length size. It will look like +this: + +public partial class Rectangle +{ + public Rectangle (int x, int y, int width, int height) + { + // JNI bindings + } +} + +Imagine we want to add a constructor to this class that takes a Point and +Size structure instead of 4 ints. We can add a new file called Rectangle.cs +with a partial class containing our new method: + +public partial class Rectangle +{ + public Rectangle (Point location, Size size) : + this (location.X, location.Y, size.Width, size.Height) + { + } +} + +At compile time, the additions class will be added to the generated class +and the final assembly will a Rectangle class with both constructors. + + +== Adding C# Classes == + +Another thing that can be done is adding fully C# managed classes to the +generated library. In the above example, let's assume that there isn't a +Point class available in Java or our library. The one we create doesn't need +to interact with Java, so we'll create it like a normal class in C#. + +By adding a Point.cs file with this class, it will end up in the binding library: + +public class Point +{ + public int X { get; set; } + public int Y { get; set; } +} diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Jars/AboutJars.txt b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Jars/AboutJars.txt new file mode 100644 index 00000000000..e833d78bc58 --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Jars/AboutJars.txt @@ -0,0 +1,36 @@ +This directory is for Android .jars. + +There are 4 types of jars that are supported: + +== Input Jar and Embedded Jar == + +This is the jar that bindings should be generated for. + +For example, if you were binding the Google Maps library, this would +be Google's "maps.jar". + +The difference between EmbeddedJar and InputJar is, EmbeddedJar is to be +embedded in the resulting dll as EmbeddedResource, while InputJar is not. +There are couple of reasons you wouldn't like to embed the target jar +in your dll (the ones that could be internally loaded by +feature e.g. maps.jar, or you cannot embed jars that are under some +proprietary license). + +Set the build action for these jars in the properties page to "InputJar". + + +== Reference Jar and Embedded Reference Jar == + +These are jars that are referenced by the input jar. C# bindings will +not be created for these jars. These jars will be used to resolve +types used by the input jar. + +NOTE: Do not add "android.jar" as a reference jar. It will be added automatically +based on the Target Framework selected. + +Set the build action for these jars in the properties page to "ReferenceJar". + +"EmbeddedJar" works like "ReferenceJar", but like "EmbeddedJar", it is +embedded in your dll. But at application build time, they are not included +in the final apk, like ReferenceJar files. + diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Jars/DefaultInterfaceMethods.java b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Jars/DefaultInterfaceMethods.java new file mode 100644 index 00000000000..84a310f5c54 --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Jars/DefaultInterfaceMethods.java @@ -0,0 +1,10 @@ +package com.xamarin.test; + +public interface DefaultInterfaceMethods +{ + default int foo () { return 0; } + default int getBar () { return 1; } + default int getBaz () { return 2; } + default void setBaz (int value) { } + default int toImplement () { throw new UnsupportedOperationException (); } +} diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Jars/ImplementedClass.java b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Jars/ImplementedClass.java new file mode 100644 index 00000000000..4feeb9c2a8a --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Jars/ImplementedClass.java @@ -0,0 +1,6 @@ +package com.xamarin.test; + +public class ImplementedClass implements DefaultInterfaceMethods +{ + public int toImplement () { return -1; } +} diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Properties/AssemblyInfo.cs b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Properties/AssemblyInfo.cs new file mode 100644 index 00000000000..895af20109e --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Properties/AssemblyInfo.cs @@ -0,0 +1,27 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using Android.App; + +// Information about this assembly is defined by the following attributes. +// Change them to the values specific to your project. + +[assembly: AssemblyTitle ("Xamarin.Android.DefaultInterfaceMethods-Lib")] +[assembly: AssemblyDescription ("")] +[assembly: AssemblyConfiguration ("")] +[assembly: AssemblyCompany ("")] +[assembly: AssemblyProduct ("")] +[assembly: AssemblyCopyright ("${AuthorCopyright}")] +[assembly: AssemblyTrademark ("")] +[assembly: AssemblyCulture ("")] + +// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}". +// The form "{Major}.{Minor}.*" will automatically update the build and revision, +// and "{Major}.{Minor}.{Build}.*" will update just the revision. + +[assembly: AssemblyVersion ("1.0.0")] + +// The following attributes are used to specify the signing key for the assembly, +// if desired. See the Mono documentation for more information about signing. + +//[assembly: AssemblyDelaySign(false)] +//[assembly: AssemblyKeyFile("")] diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Transforms/EnumFields.xml b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Transforms/EnumFields.xml new file mode 100644 index 00000000000..b95f58ccd8c --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Transforms/EnumFields.xml @@ -0,0 +1,19 @@ + + + + diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Transforms/EnumMethods.xml b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Transforms/EnumMethods.xml new file mode 100644 index 00000000000..c65a473ca7a --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Transforms/EnumMethods.xml @@ -0,0 +1,19 @@ + + + + diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Transforms/Metadata.xml b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Transforms/Metadata.xml new file mode 100644 index 00000000000..8f3bde759f9 --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Transforms/Metadata.xml @@ -0,0 +1,10 @@ + + + + diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj new file mode 100644 index 00000000000..32b14c39295 --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj @@ -0,0 +1,67 @@ + + + + + + Debug + AnyCPU + {E2F0F78B-6088-4282-A49C-122EE28611FF} + {10368E6C-D01B-4462-8E8B-01FC667A7035};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + Library + Xamarin.Android.DefaultInterfaceMethodsLib + Xamarin.Android.DefaultInterfaceMethods-Lib + v9.0 + Resources + Assets + true + class-parse + True + Latest + + + true + full + false + bin\Debug + DEBUG; + prompt + 4 + None + + + true + pdbonly + true + bin\Release + prompt + 4 + true + false + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/packages.config b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/packages.config new file mode 100644 index 00000000000..3356ed4afb5 --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/packages.config @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Assets/AboutAssets.txt b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Assets/AboutAssets.txt new file mode 100644 index 00000000000..a9b0638eb1b --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Assets/AboutAssets.txt @@ -0,0 +1,19 @@ +Any raw assets you want to be deployed with your application can be placed in +this directory (and child directories) and given a Build Action of "AndroidAsset". + +These files will be deployed with your package and will be accessible using Android's +AssetManager, like this: + +public class ReadAsset : Activity +{ + protected override void OnCreate (Bundle bundle) + { + base.OnCreate (bundle); + + InputStream input = Assets.Open ("my_asset.txt"); + } +} + +Additionally, some Android functions will automatically load asset files: + +Typeface tf = Typeface.CreateFromAsset (Context.Assets, "fonts/samplefont.ttf"); diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/MainActivity.cs b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/MainActivity.cs new file mode 100644 index 00000000000..32683ae364a --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/MainActivity.cs @@ -0,0 +1,23 @@ +using System.Reflection; + +using Android.App; +using Android.OS; +using Xamarin.Android.NUnitLite; + +namespace Xamarin.Android.DefaultInterfaceMethodsTests +{ + [Activity (Label = "Xamarin.Android.DefaultInterfaceMethods-Tests", MainLauncher = true)] + public class MainActivity : TestSuiteActivity + { + protected override void OnCreate (Bundle bundle) + { + // tests can be inside the main assembly + AddTest (Assembly.GetExecutingAssembly ()); + // or in any reference assemblies + // AddTest (typeof (Your.Library.TestClass).Assembly); + + // Once you called base.OnCreate(), you cannot add more assemblies. + base.OnCreate (bundle); + } + } +} diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Properties/AndroidManifest.xml b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Properties/AndroidManifest.xml new file mode 100644 index 00000000000..be0ab0ee935 --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Properties/AndroidManifest.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Properties/AssemblyInfo.cs b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Properties/AssemblyInfo.cs new file mode 100644 index 00000000000..a5ecc52af40 --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Properties/AssemblyInfo.cs @@ -0,0 +1,27 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using Android.App; + +// Information about this assembly is defined by the following attributes. +// Change them to the values specific to your project. + +[assembly: AssemblyTitle ("Xamarin.Android.DefaultInterfaceMethods-Tests")] +[assembly: AssemblyDescription ("")] +[assembly: AssemblyConfiguration ("")] +[assembly: AssemblyCompany ("")] +[assembly: AssemblyProduct ("")] +[assembly: AssemblyCopyright ("${AuthorCopyright}")] +[assembly: AssemblyTrademark ("")] +[assembly: AssemblyCulture ("")] + +// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}". +// The form "{Major}.{Minor}.*" will automatically update the build and revision, +// and "{Major}.{Minor}.{Build}.*" will update just the revision. + +[assembly: AssemblyVersion ("1.0.0")] + +// The following attributes are used to specify the signing key for the assembly, +// if desired. See the Mono documentation for more information about signing. + +//[assembly: AssemblyDelaySign(false)] +//[assembly: AssemblyKeyFile("")] diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/AboutResources.txt b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/AboutResources.txt new file mode 100644 index 00000000000..10f52d46021 --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/AboutResources.txt @@ -0,0 +1,44 @@ +Images, layout descriptions, binary blobs and string dictionaries can be included +in your application as resource files. Various Android APIs are designed to +operate on the resource IDs instead of dealing with images, strings or binary blobs +directly. + +For example, a sample Android app that contains a user interface layout (main.axml), +an internationalization string table (strings.xml) and some icons (drawable-XXX/icon.png) +would keep its resources in the "Resources" directory of the application: + +Resources/ + drawable/ + icon.png + + layout/ + main.axml + + values/ + strings.xml + +In order to get the build system to recognize Android resources, set the build action to +"AndroidResource". The native Android APIs do not operate directly with filenames, but +instead operate on resource IDs. When you compile an Android application that uses resources, +the build system will package the resources for distribution and generate a class called "R" +(this is an Android convention) that contains the tokens for each one of the resources +included. For example, for the above Resources layout, this is what the R class would expose: + +public class R { + public class drawable { + public const int icon = 0x123; + } + + public class layout { + public const int main = 0x456; + } + + public class strings { + public const int first_string = 0xabc; + public const int second_string = 0xbcd; + } +} + +You would then use R.drawable.icon to reference the drawable/icon.png file, or R.layout.main +to reference the layout/main.axml file, or R.strings.first_string to reference the first +string in the dictionary file values/strings.xml. diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/mipmap-hdpi/Icon.png b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/mipmap-hdpi/Icon.png new file mode 100644 index 0000000000000000000000000000000000000000..f4c804644c5e47daffed8e8573b5da99d0939bc0 GIT binary patch literal 2201 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 literal 0 HcmV?d00001 diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/mipmap-xhdpi/Icon.png b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/mipmap-xhdpi/Icon.png new file mode 100644 index 0000000000000000000000000000000000000000..b7e2e57aa90f8687bdfa19d82ff6bda71535b8d5 GIT binary patch literal 3237 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 Xx9ez7Rf!D(00000NkvXXu0mjfmS|-l literal 0 HcmV?d00001 diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/mipmap-xxhdpi/Icon.png b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Resources/mipmap-xxhdpi/Icon.png new file mode 100644 index 0000000000000000000000000000000000000000..8d20a38d1782921964638e873ffc98d148ebda6a GIT binary patch literal 5414 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 c0$sN|hZ~f>0q(p1ua5js-$bwSo@3 + + + + Debug + AnyCPU + {80E5171A-56DF-48AC-8AD9-65028319C1B8} + {EFBA0AD7-5A72-4C68-AF49-83D382785DCF};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + Library + Xamarin.Android.DefaultInterfaceMethodsTests + Xamarin.Android.DefaultInterfaceMethods-Tests + v9.0 + True + Resources\Resource.designer.cs + Resource + Resources + Assets + true + Properties\AndroidManifest.xml + armeabi-v7a;x86;arm64-v8a;x86_64 + + + true + full + false + bin\Debug + DEBUG; + prompt + 4 + None + + + true + pdbonly + true + bin\Release + prompt + 4 + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {E2F0F78B-6088-4282-A49C-122EE28611FF} + Xamarin.Android.DefaultInterfaceMethods-Lib + + + + + \ No newline at end of file diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/packages.config b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/packages.config new file mode 100644 index 00000000000..7b2eb74810c --- /dev/null +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file From 7918653d644cd7d53ed3c0f9ef1202d069c34ee1 Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Thu, 12 Jul 2018 02:16:39 +0900 Subject: [PATCH 03/18] Some cosmetic fix in default interface methods test - use latest for langver. --- .../TestsSample.cs | 14 ++++++++------ ...in.Android.DefaultInterfaceMethods-Tests.csproj | 6 +++++- 2 files changed, 13 insertions(+), 7 deletions(-) diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/TestsSample.cs b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/TestsSample.cs index 4c6a3c10f95..947da919aa2 100644 --- a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/TestsSample.cs +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/TestsSample.cs @@ -1,4 +1,5 @@ using System; +using Com.Xamarin.Test; using NUnit.Framework; namespace Xamarin.Android.DefaultInterfaceMethodsTests @@ -6,21 +7,22 @@ namespace Xamarin.Android.DefaultInterfaceMethodsTests [TestFixture] public class TestsSample { - [SetUp] public void Setup () { } - [TearDown] public void Tear () { } [Test] public void Pass () { - var c = new Com.Xamarin.Test.ImplementedClass (); - Assert.AreEqual (-1, c.ToImplement (), "#1"); - Assert.AreEqual (0, c.Foo (), "#2"); - Assert.AreEqual (1, c.Bar, "#3"); + // C# 8 syntax is awkward. + // If you use "var" then it is declared as the class, and fails to resolve. + // Those default interface methods are only callable via interface! + IDefaultInterfaceMethods c = new ImplementedClass (); + Assert.AreEqual (0, c.Foo (), "#1"); + Assert.AreEqual (1, c.Bar, "#2"); + Assert.AreEqual (-1, c.ToImplement (), "#3"); } } } diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Xamarin.Android.DefaultInterfaceMethods-Tests.csproj b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Xamarin.Android.DefaultInterfaceMethods-Tests.csproj index 594b7906758..0e45af64a9c 100644 --- a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Xamarin.Android.DefaultInterfaceMethods-Tests.csproj +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Xamarin.Android.DefaultInterfaceMethods-Tests.csproj @@ -18,6 +18,7 @@ true Properties\AndroidManifest.xml armeabi-v7a;x86;arm64-v8a;x86_64 + Latest true @@ -28,6 +29,9 @@ prompt 4 None + false + + true @@ -72,4 +76,4 @@ - \ No newline at end of file + From d688d2bd2ecf452ca12e6b77b93075302a7bb58b Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Thu, 12 Jul 2018 02:17:56 +0900 Subject: [PATCH 04/18] bump xamarin-android-buildenhancer package. Its jar build was awkward. --- .../Xamarin.Android.DefaultInterfaceMethods-Lib.csproj | 4 ++-- .../packages.config | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj index 32b14c39295..e0eb1fac94d 100644 --- a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj @@ -1,7 +1,7 @@ + - Debug AnyCPU @@ -62,6 +62,6 @@ - + diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/packages.config b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/packages.config index 3356ed4afb5..064465b6132 100644 --- a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/packages.config +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/packages.config @@ -1,5 +1,5 @@  - + \ No newline at end of file From 4109ae535ddcf8384fd216e5b115bea3cc293956 Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Thu, 12 Jul 2018 19:36:53 +0900 Subject: [PATCH 05/18] bump xamarin-android-build-enhancer to support build inputs/outputs, and fix test names. --- ...Xamarin.Android.DefaultInterfaceMethods-Lib.csproj | 11 +++++++++-- .../packages.config | 2 +- .../TestsSample.cs | 10 ++-------- 3 files changed, 12 insertions(+), 11 deletions(-) diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj index e0eb1fac94d..97e23cd3ab0 100644 --- a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj @@ -1,6 +1,6 @@ - + Debug @@ -61,7 +61,14 @@ + + + + + + + - + diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/packages.config b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/packages.config index 064465b6132..ef211d7c05d 100644 --- a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/packages.config +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/packages.config @@ -1,5 +1,5 @@  - + \ No newline at end of file diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/TestsSample.cs b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/TestsSample.cs index 947da919aa2..84f8094ddf5 100644 --- a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/TestsSample.cs +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/TestsSample.cs @@ -5,16 +5,10 @@ namespace Xamarin.Android.DefaultInterfaceMethodsTests { [TestFixture] - public class TestsSample + public class DimTest { - [SetUp] - public void Setup () { } - - [TearDown] - public void Tear () { } - [Test] - public void Pass () + public void TestCSharp8DefaultInterfaceMethods () { // C# 8 syntax is awkward. // If you use "var" then it is declared as the class, and fails to resolve. From 4d29c5a002d219c77c94b2f6e6f0feb2c084035e Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Tue, 17 Jul 2018 21:19:18 +0900 Subject: [PATCH 06/18] [linker] Do not emit AbstractMethodError thrower when target method is DIM. Context: https://github.com/xamarin/xamarin-android/pull/1939#issuecomment-405553223 --- .../Linker/MonoDroid.Tuner/FixAbstractMethodsStep.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/Xamarin.Android.Build.Tasks/Linker/MonoDroid.Tuner/FixAbstractMethodsStep.cs b/src/Xamarin.Android.Build.Tasks/Linker/MonoDroid.Tuner/FixAbstractMethodsStep.cs index 101ecc5052b..32e582c0eef 100644 --- a/src/Xamarin.Android.Build.Tasks/Linker/MonoDroid.Tuner/FixAbstractMethodsStep.cs +++ b/src/Xamarin.Android.Build.Tasks/Linker/MonoDroid.Tuner/FixAbstractMethodsStep.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using System.Linq; using Mono.Cecil; @@ -163,7 +164,7 @@ bool FixAbstractMethods (TypeDefinition type) if (ifaceDef.HasGenericParameters) continue; - foreach (var iMethod in ifaceDef.Methods) { + foreach (var iMethod in ifaceDef.Methods.Where (m => m.IsAbstract)) { bool exists = false; foreach (var tMethod in typeMethods) { From 31ec999a83c8400c39e557e19036466ec484adb5 Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Tue, 17 Jul 2018 22:00:13 +0900 Subject: [PATCH 07/18] [tests] default interface methods run-time test: make it working. --- .../Xamarin.Android.DefaultInterfaceMethods-Lib.csproj | 7 ------- .../MainActivity.cs | 6 +++++- .../Xamarin.Android.DefaultInterfaceMethods-Tests.csproj | 4 +++- 3 files changed, 8 insertions(+), 9 deletions(-) diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj index 97e23cd3ab0..78ff7a2845c 100644 --- a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Lib/Xamarin.Android.DefaultInterfaceMethods-Lib.csproj @@ -61,13 +61,6 @@ - - - - - - - diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/MainActivity.cs b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/MainActivity.cs index 32683ae364a..1e1ec957d6c 100644 --- a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/MainActivity.cs +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/MainActivity.cs @@ -1,7 +1,11 @@ -using System.Reflection; +using System; +using System.Reflection; using Android.App; using Android.OS; +using Android.Runtime; +using Com.Xamarin.Test; +using Java.Interop; using Xamarin.Android.NUnitLite; namespace Xamarin.Android.DefaultInterfaceMethodsTests diff --git a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Xamarin.Android.DefaultInterfaceMethods-Tests.csproj b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Xamarin.Android.DefaultInterfaceMethods-Tests.csproj index 0e45af64a9c..6859e10fda4 100644 --- a/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Xamarin.Android.DefaultInterfaceMethods-Tests.csproj +++ b/tests/CodeGen-Binding/Xamarin.Android.DefaultInterfaceMethods-Tests/Xamarin.Android.DefaultInterfaceMethods-Tests.csproj @@ -30,8 +30,8 @@ 4 None false - + true true @@ -41,6 +41,7 @@ prompt 4 true + true @@ -48,6 +49,7 @@ + From 5f0ff78ec64974868c00ec46477d0b94e4356acc Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Wed, 18 Jul 2018 12:31:06 +0900 Subject: [PATCH 08/18] [Mono.Android] enable default interface method generation. It results in a bunch of build failures due to lack of metadata fixup for any API glitch so far. --- src/Mono.Android/Mono.Android.targets | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/Mono.Android/Mono.Android.targets b/src/Mono.Android/Mono.Android.targets index f8242c06ada..1acde6c0f70 100644 --- a/src/Mono.Android/Mono.Android.targets +++ b/src/Mono.Android/Mono.Android.targets @@ -3,6 +3,10 @@ + + ..\..\packages\xamarin.android.csc.dim.0.1.2\tools\ + latest + @@ -78,6 +82,7 @@ "$(XAInstallPrefix)xbuild\Xamarin\Android\generator.exe" <_GenFlags>--public --product-version=7 + <_DefaultInterfaceMethods>--default-interface-methods <_ApiLevel>--api-level=$(AndroidApiLevel) <_Out>-o "$(IntermediateOutputPath)mcw" <_Codegen>--codegen-target=XAJavaInterop1 @@ -92,7 +97,7 @@ <_Dirs>--enumdir=$(IntermediateOutputPath)mcw From 0e4a32ec82c68bb995b8ef13e851f4e9bdf3e736 Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Wed, 18 Jul 2018 20:28:59 +0900 Subject: [PATCH 09/18] [Mono.Android] new metadata fixup required for Animator event methods. There are DIMs that results in managed events and args types, but those names conflict each other (onAnimationStart/onAnimationEnd overloads for each). Therefore the new methods had to be renamed. --- src/Mono.Android/metadata | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/Mono.Android/metadata b/src/Mono.Android/metadata index 1525b120dd0..c7c8ed15107 100644 --- a/src/Mono.Android/metadata +++ b/src/Mono.Android/metadata @@ -1389,6 +1389,10 @@ --> ColorObject + + AnimationStart2 + AnimationEnd2 + Java.Util.ISpliterator + + + + + + + Android.Service.QuickSettings From 938c293a7713aab80ed906ad17998b436c0f2a6a Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Thu, 19 Jul 2018 18:29:54 +0900 Subject: [PATCH 11/18] [Mono.Android] minimum workaround to make it build with DIMs generated. --- src/Mono.Android/Java.Util/Spliterators.cs | 3 +-- src/Mono.Android/metadata | 19 +++++++++++++++++++ 2 files changed, 20 insertions(+), 2 deletions(-) diff --git a/src/Mono.Android/Java.Util/Spliterators.cs b/src/Mono.Android/Java.Util/Spliterators.cs index d6a327dc480..99dbbe3de0c 100644 --- a/src/Mono.Android/Java.Util/Spliterators.cs +++ b/src/Mono.Android/Java.Util/Spliterators.cs @@ -1,4 +1,4 @@ -#if ANDROID_24 +#if false//ANDROID_24 using System; using Android.Runtime; using Java.Interop; @@ -6,7 +6,6 @@ namespace Java.Util { - // FIXME: this should not be required to be hand-bound. public partial class Spliterators { public partial class AbstractSpliterator diff --git a/src/Mono.Android/metadata b/src/Mono.Android/metadata index d3cf622fdf9..494c596a4a3 100644 --- a/src/Mono.Android/metadata +++ b/src/Mono.Android/metadata @@ -1420,4 +1420,23 @@ CarrierIdField + + false + + + java.util.function.Consumer + From f4084d17eda4f5444edd829afa5dcc2c7a42094f Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Thu, 19 Jul 2018 23:13:09 +0900 Subject: [PATCH 12/18] [Mono.Android] bring back ConcurrentSkipListMap, Fixed all the ABI breakage. --- src/Mono.Android/metadata | 1 - 1 file changed, 1 deletion(-) diff --git a/src/Mono.Android/metadata b/src/Mono.Android/metadata index 494c596a4a3..99c65ee4f56 100644 --- a/src/Mono.Android/metadata +++ b/src/Mono.Android/metadata @@ -1252,7 +1252,6 @@ and thus treated as Java.Lang.Object. It needs to be fixed. --> Java.Util.ISpliterator - From f180241680e7c602bb3d2bd68ec71614cccdd407 Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Fri, 20 Jul 2018 14:08:01 +0900 Subject: [PATCH 13/18] bump java.interop. --- external/Java.Interop | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/external/Java.Interop b/external/Java.Interop index 78f73018f0e..e6be186c23f 160000 --- a/external/Java.Interop +++ b/external/Java.Interop @@ -1 +1 @@ -Subproject commit 78f73018f0e440c80e47e21e009c6f493b7103ff +Subproject commit e6be186c23f0843a1774bafe450f535be7129128 From 652108659c77a937d4aa6e627b71c7467da89d47 Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Thu, 26 Jul 2018 19:55:51 +0900 Subject: [PATCH 14/18] xamarin.android.csc.dim needs to be nuget-restored at `make prepare`. --- src/Mono.Android/packages.config | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 src/Mono.Android/packages.config diff --git a/src/Mono.Android/packages.config b/src/Mono.Android/packages.config new file mode 100644 index 00000000000..940176f8108 --- /dev/null +++ b/src/Mono.Android/packages.config @@ -0,0 +1,5 @@ + + + + + From 01152f6a985047b502e3963530450c457f68e797 Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Thu, 26 Jul 2018 23:55:59 +0900 Subject: [PATCH 15/18] [Mono.Android] bring back some DIM related types and methods for Spliterators. --- src/Mono.Android/metadata | 54 ++++++++++++--------------------------- 1 file changed, 17 insertions(+), 37 deletions(-) diff --git a/src/Mono.Android/metadata b/src/Mono.Android/metadata index 99c65ee4f56..d1d924979ba 100644 --- a/src/Mono.Android/metadata +++ b/src/Mono.Android/metadata @@ -1208,51 +1208,31 @@ Java.Util.Concurrent.ICompletionStage - - - + Java.Lang.Object + + Java.Util.ISpliterator + Java.Util.ISpliterator + + + Java.Util.ISpliterator Java.Lang.Object Java.Util.IIterator - Java.Lang.Object - - - Java.Util.ISpliterator - From 14ab4a7c2d8862a95da444e8a1e6a1eb5959ff57 Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Fri, 27 Jul 2018 01:20:15 +0900 Subject: [PATCH 16/18] [Mono.Android] enable java.time package. Now it is practically doable with DIM support. --- src/Mono.Android/metadata | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/Mono.Android/metadata b/src/Mono.Android/metadata index d1d924979ba..7adc1ebe43a 100644 --- a/src/Mono.Android/metadata +++ b/src/Mono.Android/metadata @@ -1306,8 +1306,10 @@ AudioFocusRequestClass - + + Java.Time.Temporal.ITemporal + From 6dd52c97d5bed6d81034e489263a1f3ce4f60abe Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Fri, 27 Jul 2018 17:08:32 +0900 Subject: [PATCH 17/18] [Mono.Android] bring back java.nio.NetworkChannel and co. Since we already had some method overrides for NetworkChannel methods (that could have returned common base types by adjusting managedReturn), those return types could not be changed (because of ABI compatibility). Therefore added manual bindings to those interface members instead. --- .../AsynchronousServerSocketChannel.cs | 21 +++++++++++++ .../AsynchronousSocketChannel.cs | 21 +++++++++++++ .../Java.Nio.Channels/DatagramChannel.cs | 17 +++++++++++ .../Java.Nio.Channels/ServerSocketChannel.cs | 17 +++++++++++ .../Java.Nio.Channels/SocketChannel.cs | 17 +++++++++++ src/Mono.Android/Mono.Android.csproj | 1 + src/Mono.Android/metadata | 30 +++++-------------- 7 files changed, 101 insertions(+), 23 deletions(-) create mode 100644 src/Mono.Android/Java.Nio.Channels/AsynchronousServerSocketChannel.cs create mode 100644 src/Mono.Android/Java.Nio.Channels/AsynchronousSocketChannel.cs create mode 100644 src/Mono.Android/Java.Nio.Channels/DatagramChannel.cs create mode 100644 src/Mono.Android/Java.Nio.Channels/ServerSocketChannel.cs create mode 100644 src/Mono.Android/Java.Nio.Channels/SocketChannel.cs diff --git a/src/Mono.Android/Java.Nio.Channels/AsynchronousServerSocketChannel.cs b/src/Mono.Android/Java.Nio.Channels/AsynchronousServerSocketChannel.cs new file mode 100644 index 00000000000..60f4aa526b5 --- /dev/null +++ b/src/Mono.Android/Java.Nio.Channels/AsynchronousServerSocketChannel.cs @@ -0,0 +1,21 @@ +#if ANDROID_26 + +using System; +using Java.Net; + +namespace Java.Nio.Channels +{ + partial class AsynchronousServerSocketChannel + { + INetworkChannel INetworkChannel.Bind (SocketAddress address) + { + return Bind (address); + } + INetworkChannel INetworkChannel.SetOption (ISocketOption option, Java.Lang.Object value) + { + return SetOption (option, value); + } + } +} + +#endif diff --git a/src/Mono.Android/Java.Nio.Channels/AsynchronousSocketChannel.cs b/src/Mono.Android/Java.Nio.Channels/AsynchronousSocketChannel.cs new file mode 100644 index 00000000000..70cd94982c0 --- /dev/null +++ b/src/Mono.Android/Java.Nio.Channels/AsynchronousSocketChannel.cs @@ -0,0 +1,21 @@ +#if ANDROID_26 + +using System; +using Java.Net; + +namespace Java.Nio.Channels +{ + partial class AsynchronousSocketChannel + { + INetworkChannel INetworkChannel.Bind (SocketAddress address) + { + return Bind (address); + } + INetworkChannel INetworkChannel.SetOption (ISocketOption option, Java.Lang.Object value) + { + return SetOption (option, value); + } + } +} + +#endif diff --git a/src/Mono.Android/Java.Nio.Channels/DatagramChannel.cs b/src/Mono.Android/Java.Nio.Channels/DatagramChannel.cs new file mode 100644 index 00000000000..9c567deee43 --- /dev/null +++ b/src/Mono.Android/Java.Nio.Channels/DatagramChannel.cs @@ -0,0 +1,17 @@ +using System; +using Java.Net; + +namespace Java.Nio.Channels +{ + partial class DatagramChannel + { + INetworkChannel INetworkChannel.Bind (SocketAddress address) + { + return Bind (address); + } + INetworkChannel INetworkChannel.SetOption (ISocketOption option, Java.Lang.Object value) + { + return SetOption (option, value); + } + } +} diff --git a/src/Mono.Android/Java.Nio.Channels/ServerSocketChannel.cs b/src/Mono.Android/Java.Nio.Channels/ServerSocketChannel.cs new file mode 100644 index 00000000000..994c3165f49 --- /dev/null +++ b/src/Mono.Android/Java.Nio.Channels/ServerSocketChannel.cs @@ -0,0 +1,17 @@ +using System; +using Java.Net; + +namespace Java.Nio.Channels +{ + partial class ServerSocketChannel + { + INetworkChannel INetworkChannel.Bind (SocketAddress address) + { + return Bind (address); + } + INetworkChannel INetworkChannel.SetOption (ISocketOption option, Java.Lang.Object value) + { + return SetOption (option, value); + } + } +} diff --git a/src/Mono.Android/Java.Nio.Channels/SocketChannel.cs b/src/Mono.Android/Java.Nio.Channels/SocketChannel.cs new file mode 100644 index 00000000000..573c6a2fad7 --- /dev/null +++ b/src/Mono.Android/Java.Nio.Channels/SocketChannel.cs @@ -0,0 +1,17 @@ +using System; +using Java.Net; + +namespace Java.Nio.Channels +{ + partial class SocketChannel + { + INetworkChannel INetworkChannel.Bind (SocketAddress address) + { + return Bind (address); + } + INetworkChannel INetworkChannel.SetOption (ISocketOption option, Java.Lang.Object value) + { + return SetOption (option, value); + } + } +} diff --git a/src/Mono.Android/Mono.Android.csproj b/src/Mono.Android/Mono.Android.csproj index 2e805278a6a..f782fde347b 100644 --- a/src/Mono.Android/Mono.Android.csproj +++ b/src/Mono.Android/Mono.Android.csproj @@ -301,6 +301,7 @@ + diff --git a/src/Mono.Android/metadata b/src/Mono.Android/metadata index 7adc1ebe43a..a24cd51e720 100644 --- a/src/Mono.Android/metadata +++ b/src/Mono.Android/metadata @@ -1173,29 +1173,13 @@ public - - - - - - + + + + java.net.SocketOption + Java.Lang.Object + Java.Lang.Object public From e0e42e269139fe98053dc3b5a507afb6bbf72083 Mon Sep 17 00:00:00 2001 From: Atsushi Eno Date: Mon, 30 Jul 2018 14:23:53 +0900 Subject: [PATCH 18/18] [docs] add documentation about default interface methods. --- .../project-docs/DefaultInterfaceMethods.md | 144 ++++++++++++++++++ 1 file changed, 144 insertions(+) create mode 100644 Documentation/project-docs/DefaultInterfaceMethods.md diff --git a/Documentation/project-docs/DefaultInterfaceMethods.md b/Documentation/project-docs/DefaultInterfaceMethods.md new file mode 100644 index 00000000000..688218abc13 --- /dev/null +++ b/Documentation/project-docs/DefaultInterfaceMethods.md @@ -0,0 +1,144 @@ +# Xamarin.Android and C# 8.0 default interface methods + +We have been trying to implement support for C# 8.0 default interface methods (DIMs) in Xamarin.Android, to reflect Java 8 default interface methods (DIMs). Here we are going to write some notes about it. + +## Reference materials + +There are [couple](https://github.com/dotnet/csharplang/issues/52) [of](https://github.com/dotnet/csharplang/issues/288) [relevant](https://github.com/dotnet/csharplang/blob/master/proposals/default-interface-methods.md) [issues](https://github.com/dotnet/roslyn/issues/17952) (and docs), but not everything is consistent. This post is written based on the implementation (mono's `csc-dim` version of csc) I have been using and packaging. + +## What are different from Java + +The feature is similar, but there are actually some caucious differences. + +This is how C# 8.0 DIMs work: + +``` +~/Desktop$ cat dim.cs +using System; + +public interface IFoo +{ + int X () { return 1; } + int Y => 2; +} + +public class Bar : IFoo +{ +} + +public class Baz +{ + public static void Main () + { + var bar = new Bar (); + var foo = (IFoo) bar; + Console.WriteLine (foo.X ()); + Console.WriteLine (bar.X ()); + } +} +~/Desktop$ csc-dim dim.cs -langversion:latest +Microsoft (R) Visual C# Compiler version 42.42.42.42424 () +Copyright (C) Microsoft Corporation. All rights reserved. + +dim.cs(20,26): error CS1061: 'Bar' does not contain a definition for 'X' and no extension method 'X' accepting a first argument of type 'Bar' could be found (are you missing a using directive or an assembly reference?) +``` + +(`csc-dim` is a special C# compiler distributed in the latest mono, which is anohter roslyn csc build which enabled C# 8 DIMs. We need `-langversion:latest` to actually use DIMs even with it.) + +You cannot call `new Bar ().X ()` because `X()` does not exist in `Bar`. In Java 8, `Bar.X()` is publicly accessible. In current C# 8.0 language specification, `Bar.X()` is **explicitly implemented** and **has no public API**. It's like existing non-DIMs that are not implicitly declared in a class. + +(It is explained at https://github.com/dotnet/csharplang/issues/288#issue-215243291 too. See "Concrete methods in interfaces".) + +It is actually argurable design, but that is another story. we're explaining only the fact part. + +It should be noted that we are under different circumstances than others: + +- We have no control over the API. We have no position to define API. Even Googlers don't especially in java.\* API. +- Android API, or even Java 8 API, has grown up to convert non-DIMs to DIMs. +- We have existing customers who have implemented existing Xamarin.Android interfaces. + +Therefore my investigation on C# 8.0 DIMs was in quite different direction from what others do/did. + +Let's see what kinf of default interface methods Android API has: + +- `java.lang.Iterable#spliterator()` is a DIM which was added at API Level 24 (Android N). Google had moved to OpenJDK class libraries at API Level 24 and there was a bunch of additions like this. +- Similarly, `java.lang.Iterable#remove()` is a DIM, but it had existed before API Level 24 as non-DIM. Since this method was public, there would be customers who have used this method. + + +Would there be any behavioral difference result in that Xamarin.Android cannot support DIMs? Not anything so far. + +What happens if, some customer has code that uses this non-default version of the method, like: + +``` +public class MyIterator : Java.Lang.IIterator +{ + // (there must be customer implementation of Remove() because it was not default before) + public void Remove () { ... } +} + +public void ReduceAndSkipSome (MyIterator iterator) +{ + IIterator i = iterator; // RValue can be anything. This is a PoC so just let it as is, but with explicit interface type. + while (i.HasNext ()) { + var current = i.Next (); + if (MatchesSomeCondition (current) + i.Remove (); // therefore it should still compile. + } +} +``` + +This will work. + +What if once we replace non-DIM IIterator.Remove() with a DIM, and customer rebuilt project without touching any of their source code, will it invoke `MyIterator.Remove()` ? The answer is **yes**. It is not `IIterator.Remove()` and it should still work just like it used to do. + +There won't be ABI breakage, but there is a problem that Java developers won't face. If a Xamarin.Android interface provides some DIMs and a third party library class `C` implements it without implicitly overriding it, the class is not as useful as one in Java, because of the reason I explained at first. There is no callable `new Bar().X()` where `X` is a DIM in `Foo` which `Bar` implements. + +To avoid that uselessness, the `C` developer needs to override ALL those DIMs. That's what current specification supporters claim developers to do. The current specification is likely the most consistent with the existing interface specification indeed. + +Another case Java developers would get stuck: + +``` +public interface IComparer +{ + int Compare (Object o1, Object o2); +} +public interface IList +{ + void Sort (IComparer comparer) { ... } // DIM +} +public class Vector : IList { ... } // implements everything in IList +public class MyVector : Vector +{ + void IList.Sort (IComparer comparer) { ...} // ERROR!! +} +``` + +This doesn't compile because "`MyVector` does not implement `IList`"... to make it compile, you will have to explicitly add `IList` as an implemented interface to `MyVector` declaration: + +``` +public class MyVector : Vector, IList { ... } +``` + +Then it will compile (and you don't have to implement non-DIMs in `IList` because `Vector` implements them). It is weird but that's how C# works. + + +### What Xamarin.Android currently does + +In the stable releases as of now, we don't bind any "new" default interface methods because generating them as non-default interface methods means the interface will be messy to implement (for example, what if you are told "you are supposed to implement `forEachRemaining()` and `remove()` in all of your `Iterator` implementation classes" ?). It is safe to ignore them because they don't need implementation. + +On the other hand, we generate managed methods for default interface methods IF they had existed as non-DIM in the earlier API Levels. There is a supplemental reason for that: `Mono.Android.dll` is offered per API Level, but it is not only from the corresponding API Level. Each `Mono.Android.dll` is a result of "merging" APIs from the earlier API. It is to bring API consistency across API Levels (if you look for `api-merge` in `xamarin-android/src/Mono.Android/Mono.Android.targets` you'll see how it is done). With this API model, it kind of makes sense to keep non-DIM as is, regardless of whether it is DIM now or not. + +For example, `javax.security.auth.Destroyable#destroy()` is a DIM in API Level 24 or later, but we mark it as non-DIM because it had existed since API Level 1. + + +### What Xamarin.Android will change + +We keep "already existed as non-DIMs" as is i.e. `Javax.Security.Auth.Destroyable.Destroy()` will remain DIM. I'm not sure if we will ever change that. This means Xamarin.Android application and library developers will be suffered from "extraneous work to implement some interface methods" to some extent. + +On the other hand, there will be totally new interface methods as DIMs such as `Java.Util.IIterator.ForEachRemaining()`. + +For non-abstract overrides such as `Java.Util.IPrimitiveIteratorOfDouble.ForEachRemaining()`, it will override the DIM as non-abstract, explicitly. + +For abstract overrides such as `Java.Util.IPrimitiveIterator.ForEachRemaining()`, it will override the DIM as abstract, explicitly. + +