[XamlBuild] Sync API9 to API10

diff --git a/pkg/Tizen.NET.API10/xamlbuild/Tizen.NUI.XamlBuild.dll b/pkg/Tizen.NET.API10/xamlbuild/Tizen.NUI.XamlBuild.dll
index 98917ac..c09c5dc 100644 (file)
Binary files a/pkg/Tizen.NET.API10/xamlbuild/Tizen.NUI.XamlBuild.dll and b/pkg/Tizen.NET.API10/xamlbuild/Tizen.NUI.XamlBuild.dll differ

diff --git a/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/CreateObjectVisitor.cs b/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/CreateObjectVisitor.cs
index 6d11ee5..d963f22 100755 (executable)
--- a/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/CreateObjectVisitor.cs
+++ b/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/CreateObjectVisitor.cs
@@ -284,7 +284,25 @@ namespace Tizen.NUI.Xaml.Build.Tasks
                     var ctor = Module.ImportReference(ctorinforef);
                     //                    IL_0001:  newobj instance void class [Tizen.NUI.Xaml.UIComponents]Tizen.NUI.Xaml.UIComponents.Button::'.ctor'()
                     //                    IL_0006:  stloc.0 
-                    Context.IL.Emit(OpCodes.Newobj, ctor);
+                    bool isConvertValue = false;
+                    if (node.CollectionItems.Count == 1 && node.CollectionItems.First() is ValueNode valueNode)
+                    {
+                        if (valueNode.CanConvertValue(Context.Module, typeref, (TypeReference)null))
+                        {
+                            var converterType = valueNode.GetConverterType(new ICustomAttributeProvider[] { typeref.Resolve() });
+                            if (null != converterType)
+                            {
+                                isConvertValue = true;
+                                Context.IL.Append(vnode.PushConvertedValue(Context, typeref, new ICustomAttributeProvider[] { typedef },
+                                    node.PushServiceProvider(Context), false, true));
+                            }
+                        }
+                    }
+                    
+                    if (false == isConvertValue)
+                    {
+                        Context.IL.Emit(OpCodes.Newobj, ctor);
+                    }
                     Context.IL.Emit(OpCodes.Stloc, vardef);
                 }
                 else if (ctorInfo != null && node.Properties.ContainsKey(XmlName.xArguments) &&
@@ -525,7 +543,7 @@ namespace Tizen.NUI.Xaml.Build.Tasks
             if (node.NamespaceURI == XamlParser.X2009Uri)
             {
                 var n = node.XmlType.Name.Split(':')[1];
-                return n != "Array";
+                return n != "Array" && n != "Nullable";
             }
             if (node.NamespaceURI != "clr-namespace:System;assembly=mscorlib")
                 return false;

diff --git a/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/NodeILExtensions.cs b/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/NodeILExtensions.cs
index 54a39a5..41bd449 100755 (executable)
--- a/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/NodeILExtensions.cs
+++ b/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/NodeILExtensions.cs
@@ -353,8 +353,16 @@ namespace Tizen.NUI.Xaml.Build.Tasks
             if (compiledConverterName != null && (compiledConverterType = Type.GetType (compiledConverterName)) != null) {
                 var compiledConverter = Activator.CreateInstance (compiledConverterType);
                 var converter = typeof(ICompiledTypeConverter).GetMethods ().FirstOrDefault (md => md.Name == "ConvertFromString");
-                IEnumerable<Instruction> instructions = (IEnumerable<Instruction>)converter.Invoke (compiledConverter, new object[] {
-                    node.Value as string, context, node as BaseNode});
+                IEnumerable<Instruction> instructions = null;
+
+                try
+                {
+                    instructions = (IEnumerable<Instruction>)converter.Invoke(compiledConverter, new object[] {
+                        node.Value as string, context, node as BaseNode});
+                }
+                catch 
+                {
+                }
 
                 if (null != instructions)
                 {

diff --git a/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/XamlCTask.cs b/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/XamlCTask.cs
index 038bf95..8827aff 100755 (executable)
--- a/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/XamlCTask.cs
+++ b/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/XamlCTask.cs
@@ -47,6 +47,8 @@ namespace Tizen.NUI.Xaml.Build.Tasks
 
         public bool UseInjection { get; set; }
 
+        public int XamlOptimization { get; set; } = 2;
+
         public IAssemblyResolver DefaultAssemblyResolver { get; set; }
 
         public string Type { get; set; }
@@ -284,10 +286,16 @@ namespace Tizen.NUI.Xaml.Build.Tasks
                             continue;
                         }
 
-                        bool currentRetOfType;
-                        IList<Exception> currentExceptionsOfType;
+                        bool currentRetOfType = false;
+                        IList<Exception> currentExceptionsOfType = null;
 
-                        if (UseInjection)
+                        if(UseInjection) XamlOptimization = 1;
+                        LoggingHelper.LogWarning($"XamlOptimization is {XamlOptimization}.");
+                        if (0 == XamlOptimization)
+                        {//Use Xaml
+                            currentRetOfType = true;
+                        }
+                        else if (1 == XamlOptimization)
                         {
                             currentRetOfType = DoInjection(typeDef, resource, out currentExceptionsOfType);
                         }

diff --git a/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/XamlGTask.cs b/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/XamlGTask.cs
index 6813ba4..76c3e1d 100755 (executable)
--- a/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/XamlGTask.cs
+++ b/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/XamlGTask.cs
@@ -36,6 +36,7 @@ namespace Tizen.NUI.Xaml.Build.Tasks
         public string AssemblyName { get; set; }
         public string DependencyPaths { get; set; }
         public string ReferencePath { get; set; }
+        public int XamlOptimization {get; set;} = 2;
         public bool AddXamlCompilationAttribute { get; set; }
         public bool PrintReferenceAssemblies { get; set; }
 
@@ -88,6 +89,7 @@ namespace Tizen.NUI.Xaml.Build.Tasks
 
                 var generator = new XamlGenerator(xamlFile, Language, AssemblyName, outputFile, ReferencePath, Log);
                 generator.AddXamlCompilationAttribute = AddXamlCompilationAttribute;
+                generator.XamlOptimization = XamlOptimization;
                 generator.ReferencePath = ReferencePath;
 
                 try {

diff --git a/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/XamlGenerator.cs b/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/XamlGenerator.cs
index 49e7efd..1f2fa72 100755 (executable)
--- a/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/XamlGenerator.cs
+++ b/src/Tizen.NUI.XamlBuild/src/public/XamlBuild/XamlGenerator.cs
@@ -19,6 +19,7 @@ using System.CodeDom;
 using System.CodeDom.Compiler;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 using System.Xml;
 using Microsoft.Build.Framework;
@@ -187,6 +188,7 @@ namespace Tizen.NUI.Xaml.Build.Tasks
         public string RootClrNamespace { get; private set; }
         public string RootType { get; private set; }
         public bool AddXamlCompilationAttribute { get; set; }
+        public int XamlOptimization { get; set; }
         bool GenerateDefaultCtor { get; set; }
         bool HideFromIntellisense { get; set; }
         bool XamlResourceIdOnly { get; set; }
@@ -357,18 +359,32 @@ namespace Tizen.NUI.Xaml.Build.Tasks
             declType.Members.Add(initcomp);
 
             //Create and initialize fields
-            var loadExaml_invoke = new CodeMethodInvokeExpression(
-                new CodeTypeReferenceExpression(new CodeTypeReference($"global::Tizen.NUI.EXaml.EXamlExtensions")),
-                "LoadFromEXamlByRelativePath", new CodeThisReferenceExpression(), 
-                new CodeMethodInvokeExpression()
-                { Method = new CodeMethodReferenceExpression() { MethodName = "GetEXamlPath" } });
-
-            CodeAssignStatement assignEXamlObject = new CodeAssignStatement(
-                    new CodeVariableReferenceExpression("eXamlData"), loadExaml_invoke);
 
-            initcomp.Statements.Add(assignEXamlObject);
+                       if(0 == XamlOptimization)
+                       {
+                initcomp.Statements.Add(new CodeMethodInvokeExpression(
+                    new CodeTypeReferenceExpression(new CodeTypeReference($"global::{typeof(Extensions).FullName}")),
+                    "LoadFromXaml", new CodeThisReferenceExpression(), new CodeTypeOfExpression(declType.Name)));
+                       }
+            else
+                       {
+                var loadExaml_invoke = new CodeMethodInvokeExpression(
+                    new CodeTypeReferenceExpression(new CodeTypeReference($"global::Tizen.NUI.EXaml.EXamlExtensions")),
+                    "LoadFromEXamlByRelativePath", new CodeThisReferenceExpression(),
+                    new CodeMethodInvokeExpression()
+                    { Method = new CodeMethodReferenceExpression() { MethodName = "GetEXamlPath" } });
+
+                CodeAssignStatement assignEXamlObject = new CodeAssignStatement(
+                        new CodeVariableReferenceExpression("eXamlData"), loadExaml_invoke);
+
+                initcomp.Statements.Add(assignEXamlObject);
+                       }
 
             foreach (var namedField in NamedFields) {
+                if(namedField.Type.BaseType.Contains("-"))
+                {
+                    namedField.Type.BaseType = namedField.Type.BaseType.Replace("-", ".");
+                }
                 declType.Members.Add(namedField);
 
                 var find_invoke = new CodeMethodInvokeExpression(
@@ -383,27 +399,29 @@ namespace Tizen.NUI.Xaml.Build.Tasks
                 initcomp.Statements.Add(assign);
             }
 
-            declType.Members.Add(new CodeMemberField
-            {
-                Name = "eXamlData",
-                Type = new CodeTypeReference("System.Object"),
-                Attributes = MemberAttributes.Private,
-                CustomAttributes = { GeneratedCodeAttrDecl }
-            });
-
-            var getEXamlPathcomp = new CodeMemberMethod()
-            {
-                Name = "GetEXamlPath",
-                ReturnType = new CodeTypeReference(typeof(string)),
-                CustomAttributes = { GeneratedCodeAttrDecl }
-            };
+                       if(0 != XamlOptimization)
+                       {
+                declType.Members.Add(new CodeMemberField
+                {
+                    Name = "eXamlData",
+                    Type = new CodeTypeReference("System.Object"),
+                    Attributes = MemberAttributes.Private,
+                    CustomAttributes = { GeneratedCodeAttrDecl }
+                });
 
-            getEXamlPathcomp.Statements.Add(new CodeMethodReturnStatement(new CodeDefaultValueExpression(new CodeTypeReference(typeof(string)))));
+                var getEXamlPathcomp = new CodeMemberMethod()
+                {
+                    Name = "GetEXamlPath",
+                    ReturnType = new CodeTypeReference(typeof(string)),
+                    CustomAttributes = { GeneratedCodeAttrDecl }
+                };
 
-            declType.Members.Add(getEXamlPathcomp);
+                getEXamlPathcomp.Statements.Add(new CodeMethodReturnStatement(new CodeDefaultValueExpression(new CodeTypeReference(typeof(string)))));
 
-            GenerateMethodExitXaml(declType);
+                declType.Members.Add(getEXamlPathcomp);
 
+                GenerateMethodExitXaml(declType);
+                       }
         writeAndExit:
             //write the result
             using (var writer = new StreamWriter(outFilePath))