xamarin
/
xamarin-macios
зеркало из
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
xamarin-macios/msbuild/Xamarin.Shared/Xamarin.Shared.targets

1159 строки
60 KiB
Plaintext
Исходник Обычный вид История

Add 'NoBindingEmbedding' style binding project support (#5167) - Existing binding projects embed the native libraries within the assembly as managed resource - This does not scale well and has performance implications - This PR creates a new property, NoBindingEmbedding which when true processes the building and consumption of binding projects differently. - Existing binding projects are not affected, they will continue as is - I've written a full XM test suite and ported a subset to iOS. Since iOS only supports checked in projects, and I didn't want to make the existing situation worse by adding more, I only wrote tests that could use the existing test projects. -When we complete some form of msbuild testing reform, we'll revisit these tests. - Remove two files in MyiOSFrameworkBinding that are not used (we use copies elsewhere) - Remove unnecessary sleep and fix broken touch command - Output failing test log to console instead of test output - VSfM does not handle thousands of lines of test failure message well - Add ability to generate binding projects with LinkWith
2018-12-12 17:55:57 +03:00
<!--
***********************************************************************************************
Xamarin.Shared.targets
WARNING: DO NOT MODIFY this file unless you are knowledgeable about MSBuild and have
created a backup copy. Incorrect changes to this file will make it
impossible to load or build your projects from the command-line or the IDE.
This file imports the version- and platform-specific targets for the project importing
this file. This file also defines targets to produce an error if the specified targets
file does not exist, but the project is built anyway (command-line or IDE build).
Copyright (C) 2018 Microsoft. All rights reserved.
***********************************************************************************************
-->
<!-- This is shared between Xamarin.iOS and Xamarin.Mac -->
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
[msbuild] Add a GetMinimumOSVersion target that reads the app manifest and outputs the MinimumOSVersion. (#8858) This makes it possible for several other tasks to take the MinimumOSVersion as direct input, instead of the app manifest's path. Previously the app manifest (Info.plist) was loaded and parsed in each task, slightly differently in each place, and in addition there are differences between macOS and other platforms, which made it even worse. This code refactoring also made it possible to remove an error code which wasn't necessary anymore. This task also computes the default MinimumOSVersion if none is specified in the app manifest. There is one breaking change: a library project could previously specify an inexistent Info.plist, and it would build fine. This will now result in a "Error loading 'Info.plist': File not found" error. This is trivial to fix: just remove the Info.plist from the project file (or an alternative solution could be to condition the inclusion of the Info.plist in the project file on the existence of the Info.plist). New commits in xamarin/Xamarin.MacDev: * xamarin/Xamarin.MacDev@a1bc6f3 [Xamarin.MacDev] Split IAppleSdkVersion.TryParse in two methods. (#73) Diff: https://github.com/xamarin/Xamarin.MacDev/compare/45c5a680e20a209ac846a32e0f2f0f83e843ab76..a1bc6f39b3efe5d817c60d78eaff3f4c2de720ea
2020-06-16 18:40:04 +03:00
<PropertyGroup Condition="'$(_TaskAssemblyName)' == ''">
[msbuild] Unify all the UsingTask statements. (#8998) Some of these have been duplicated across various targets files, and when adding a new task it's annoying to forget to add it somewhere. So just have them all in the same place, so that they're loaded in every file. There are still duplicates between the iOS and Mac tasks, but those will be unified in a later PR.
2020-07-07 16:52:06 +03:00
<_TaskAssemblyName Condition="'$(_PlatformName)' == 'iOS' Or '$(_PlatformName)' == 'tvOS' Or '$(_PlatformName)' == 'watchOS'">$(MSBuildThisFileDirectory)..\iOS\Xamarin.iOS.Tasks.dll</_TaskAssemblyName>
<_TaskAssemblyName Condition="'$(_PlatformName)' == 'macOS'">$(MSBuildThisFileDirectory)Xamarin.Mac.Tasks.dll</_TaskAssemblyName>
[msbuild] Add a GetMinimumOSVersion target that reads the app manifest and outputs the MinimumOSVersion. (#8858) This makes it possible for several other tasks to take the MinimumOSVersion as direct input, instead of the app manifest's path. Previously the app manifest (Info.plist) was loaded and parsed in each task, slightly differently in each place, and in addition there are differences between macOS and other platforms, which made it even worse. This code refactoring also made it possible to remove an error code which wasn't necessary anymore. This task also computes the default MinimumOSVersion if none is specified in the app manifest. There is one breaking change: a library project could previously specify an inexistent Info.plist, and it would build fine. This will now result in a "Error loading 'Info.plist': File not found" error. This is trivial to fix: just remove the Info.plist from the project file (or an alternative solution could be to condition the inclusion of the Info.plist in the project file on the existence of the Info.plist). New commits in xamarin/Xamarin.MacDev: * xamarin/Xamarin.MacDev@a1bc6f3 [Xamarin.MacDev] Split IAppleSdkVersion.TryParse in two methods. (#73) Diff: https://github.com/xamarin/Xamarin.MacDev/compare/45c5a680e20a209ac846a32e0f2f0f83e843ab76..a1bc6f39b3efe5d817c60d78eaff3f4c2de720ea
2020-06-16 18:40:04 +03:00
</PropertyGroup>
[msbuild] Unify all the UsingTask statements. (#8998) Some of these have been duplicated across various targets files, and when adding a new task it's annoying to forget to add it somewhere. So just have them all in the same place, so that they're loaded in every file. There are still duplicates between the iOS and Mac tasks, but those will be unified in a later PR.
2020-07-07 16:52:06 +03:00
<!-- Tasks that override built-in tasks to support remoting from VS/Windows -->
<UsingTask TaskName="Microsoft.Build.Tasks.Copy" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Microsoft.Build.Tasks.Delete" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Microsoft.Build.Tasks.Exec" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Microsoft.Build.Tasks.MakeDir" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Microsoft.Build.Tasks.Move" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Microsoft.Build.Tasks.RemoveDir" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Microsoft.Build.Tasks.Touch" AssemblyFile="$(_TaskAssemblyName)" />
<!-- Xamarin.iOS-specific tasks. Some of these are duplicated with the Xamarin.Mac ones below, and should eventually be re-namespaced to be in Xamarin.MacDev -->
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.ACTool" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.ALToolUpload" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.ALToolValidate" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.Archive" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.BTouch" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.CodesignVerify" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.CollectAssetPacks" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.CollectITunesArtwork" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.CollectITunesSourceFiles" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.CompileAppManifest" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.CompileEntitlements" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.CompileITunesMetadata" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.CompileSceneKitAssets" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.CreateAssetPack" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.CreateBindingResourcePackage" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.CreateDebugConfiguration" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.CreateDebugSettings" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.CreateEmbeddedResources" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.DetectDebugNetworkConfiguration" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.DetectSdkLocations" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.DetectSigningIdentity" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.EmbedMobileProvision" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.FindWatchOS2AppBundle" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.GetDirectories" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.GetFiles" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.GetFullPath" AssemblyFile="$(_TaskAssemblyName)" />
[dotnet] Add support for 'dotnet build -t:run'. (#9823) * Ship mlaunch in the iOS, tvOS and watchOS NuGets. It should probably go into a separate NuGet (to avoid shipping the same mlaunch executable in three different packages), but that can be done at a later stage. * Add a GetMlaunchArguments task that computes the mlaunch arguments to install or launch an app in either the simulator or on device. * Implement the MSBuild logic to make the Run target (provided by .NET) launch mlaunch (for iOS, tvOS and watchOS) or the built app (for macOS). This is done by setting the RunCommand and RunArguments properties (which the Run target uses) to the correct values. Ideally I'd would make 'dotnet run' work too, but that runs into a different problem which I haven't figured out yet: A fatal error was encountered. The library 'libhostpolicy.dylib' required to execute the application was not found in '/Users/rolf/work/maccore/onedotnet/xamarin-macios/tests/dotnet/MySingleView/bin/Debug/net5.0-ios/ios-x64/'. Failed to run as a self-contained app. - The application was run as a self-contained app because '/Users/rolf/work/maccore/onedotnet/xamarin-macios/tests/dotnet/MySingleView/bin/Debug/net5.0-ios/ios-x64/MySingleView.runtimeconfig.json' did not specify a framework. - If this should be a framework-dependent app, specify the appropriate framework in '/Users/rolf/work/maccore/onedotnet/xamarin-macios/tests/dotnet/MySingleView/bin/Debug/net5.0-ios/ios-x64/MySingleView.runtimeconfig.json'. That's for a different pull request though. Ref: https://github.com/xamarin/net6-samples/issues/35.
2020-10-09 14:01:13 +03:00
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.GetMlaunchArguments" AssemblyFile="$(_TaskAssemblyName)" />
[msbuild] Unify all the UsingTask statements. (#8998) Some of these have been duplicated across various targets files, and when adding a new task it's annoying to forget to add it somewhere. So just have them all in the same place, so that they're loaded in every file. There are still duplicates between the iOS and Mac tasks, but those will be unified in a later PR.
2020-07-07 16:52:06 +03:00
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.IBTool" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.Metal" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.MetalLib" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.MTouch" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.OptimizeImage" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.OptimizePropertyList" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.ParseDeviceSpecificBuildInformation" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.PrepareNativeReferences" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.ResolveNativeWatchApp" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.ScnTool" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.TextureAtlas" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.ValidateAppBundleTask" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' != 'macOS'" TaskName="Xamarin.iOS.Tasks.WriteAssetPackManifest" AssemblyFile="$(_TaskAssemblyName)" />
<!-- Xamarin.Mac-specific tasks. Some of these are duplicated with the Xamarin.iOS ones above, and should eventually be re-namespaced to be in Xamarin.MacDev -->
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.ACTool" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.Archive" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.BTouch" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.CodesignVerify" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.CompileAppManifest" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.CompileEntitlements" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.CompileSceneKitAssets" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.CreateBindingResourcePackage" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.CreateEmbeddedResources" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.DetectSdkLocations" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.DetectSigningIdentity" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.EmbedProvisionProfile" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.IBTool" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.Metal" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.MetalLib" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.Mmp" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.PrepareNativeReferences" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.ScnTool" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask Condition="'$(_PlatformName)' == 'macOS'" TaskName="Xamarin.Mac.Tasks.TextureAtlas" AssemblyFile="$(_TaskAssemblyName)" />
<!-- Tasks shared between Xamarin.iOS and Xamarin.Mac -->
<UsingTask TaskName="Xamarin.MacDev.Tasks.ArTool" AssemblyFile="$(_TaskAssemblyName)" />
[dotnet] Implement AOT compilation for mobile platforms (#9962) * Add an AOTCompile task that runs the AOT compiler for a given set of input assemblies. This task will eventually be deprecated by an equivalent task provided by Mono, but this works for now. * Add an _AOTCompile target that takes care of running the AOT compiler and compile the result into object files.
2020-10-27 17:16:34 +03:00
<UsingTask TaskName="Xamarin.MacDev.Tasks.AOTCompile" AssemblyFile="$(_TaskAssemblyName)" />
[msbuild] Unify all the UsingTask statements. (#8998) Some of these have been duplicated across various targets files, and when adding a new task it's annoying to forget to add it somewhere. So just have them all in the same place, so that they're loaded in every file. There are still duplicates between the iOS and Mac tasks, but those will be unified in a later PR.
2020-07-07 16:52:06 +03:00
<UsingTask TaskName="Xamarin.MacDev.Tasks.Codesign" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.CollectBundleResources" AssemblyFile="$(_TaskAssemblyName)" />
[mac] Add user-framework support for Xamarin.Mac (#10144) * Move existing tests to iOS subdirectory and adjust reference paths
2020-11-26 16:47:41 +03:00
<UsingTask TaskName="Xamarin.MacDev.Tasks.CollectFrameworks" AssemblyFile="$(_TaskAssemblyName)" />
[msbuild] Unify the logic to copy bundle resources to the app. (#8987) * For Xamarin.Mac, this means using the _ComputeBundleResourceOutputPaths and _CopyResourcesToBundle targets from Xamarin.iOS instead of the _CopyContentToBundle target (which is now unused and thus removed). * Adapt the Xamarin.iOS logic (now shared) to handle the fact that the resources shouldn't always go into the root appbundle directory (since they go into Contents/Resources/ for macOS apps), by using the '_AppResourcesPath' variable to specify just this. Once upon a time the Xamarin.iOS logic was identical to the Xamarin.Mac logic, but then we implemented support for asset packs (https://github.com/xamarin/maccore/commit/a98693f07e3f7675773e1f371392c05ff178d3d4) and the code diverged. This means that unifying the logic again is a step towards making asset packs work for Xamarin.Mac apps.
2020-07-03 12:00:36 +03:00
<UsingTask TaskName="Xamarin.MacDev.Tasks.ComputeBundleResourceOutputPaths" AssemblyFile="$(_TaskAssemblyName)" />
[msbuild] Unify all the UsingTask statements. (#8998) Some of these have been duplicated across various targets files, and when adding a new task it's annoying to forget to add it somewhere. So just have them all in the same place, so that they're loaded in every file. There are still duplicates between the iOS and Mac tasks, but those will be unified in a later PR.
2020-07-07 16:52:06 +03:00
<UsingTask TaskName="Xamarin.MacDev.Tasks.CoreMLCompiler" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.CreateAssetPackManifest" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.CreateInstallerPackage" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.CreatePkgInfo" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.Ditto" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.DSymUtil" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.FindItemWithLogicalName" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.GenerateBundleName" AssemblyFile="$(_TaskAssemblyName)" />
[msbuild] Add a GetMinimumOSVersion target that reads the app manifest and outputs the MinimumOSVersion. (#8858) This makes it possible for several other tasks to take the MinimumOSVersion as direct input, instead of the app manifest's path. Previously the app manifest (Info.plist) was loaded and parsed in each task, slightly differently in each place, and in addition there are differences between macOS and other platforms, which made it even worse. This code refactoring also made it possible to remove an error code which wasn't necessary anymore. This task also computes the default MinimumOSVersion if none is specified in the app manifest. There is one breaking change: a library project could previously specify an inexistent Info.plist, and it would build fine. This will now result in a "Error loading 'Info.plist': File not found" error. This is trivial to fix: just remove the Info.plist from the project file (or an alternative solution could be to condition the inclusion of the Info.plist in the project file on the existence of the Info.plist). New commits in xamarin/Xamarin.MacDev: * xamarin/Xamarin.MacDev@a1bc6f3 [Xamarin.MacDev] Split IAppleSdkVersion.TryParse in two methods. (#73) Diff: https://github.com/xamarin/Xamarin.MacDev/compare/45c5a680e20a209ac846a32e0f2f0f83e843ab76..a1bc6f39b3efe5d817c60d78eaff3f4c2de720ea
2020-06-16 18:40:04 +03:00
<UsingTask TaskName="Xamarin.MacDev.Tasks.GetMinimumOSVersion" AssemblyFile="$(_TaskAssemblyName)" />
[msbuild] Unify all the UsingTask statements. (#8998) Some of these have been duplicated across various targets files, and when adding a new task it's annoying to forget to add it somewhere. So just have them all in the same place, so that they're loaded in every file. There are still duplicates between the iOS and Mac tasks, but those will be unified in a later PR.
2020-07-07 16:52:06 +03:00
<UsingTask TaskName="Xamarin.MacDev.Tasks.GetNativeExecutableName" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.GetPropertyListValue" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.PackLibraryResources" AssemblyFile="$(_TaskAssemblyName)" />
[msbuild] Make the ParseExtraMtouchArgs task platform-agnostic, and share it between Xamarin.iOS and Xamarin.Mac. (#9061) * Change the parsing code slightly, to make it easier to parse other arguments (coming soon). * Add the parsing task to Xamarin.Mac projects, and use it there as well. The parsed result isn't used yet, but it will be soon. * Unify a few related MSBuild properties (MtouchNoSymbolStrip and MtouchNoDSymUtil).
2020-07-13 15:56:34 +03:00
<UsingTask TaskName="Xamarin.MacDev.Tasks.ParseBundlerArguments" AssemblyFile="$(_TaskAssemblyName)" />
[msbuild] Move Xamarin.iOS' implementation of the PrepareResourceRules task to Xamarin.MacDev.Tasks. (#9318)
2020-08-07 15:54:38 +03:00
<UsingTask TaskName="Xamarin.MacDev.Tasks.PrepareResourceRules" AssemblyFile="$(_TaskAssemblyName)" />
[msbuild] Unify all the UsingTask statements. (#8998) Some of these have been duplicated across various targets files, and when adding a new task it's annoying to forget to add it somewhere. So just have them all in the same place, so that they're loaded in every file. There are still duplicates between the iOS and Mac tasks, but those will be unified in a later PR.
2020-07-07 16:52:06 +03:00
<UsingTask TaskName="Xamarin.MacDev.Tasks.PropertyListEditor" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.ReadItemsFromFile" AssemblyFile="$(_TaskAssemblyName)" />
[msbuild] Add support for `.xcframework` (#10046) This is done early so we can resolve the inner framework, inside the xcframework, and let the existing framework support do most of the work. The resolving code has unit tests. Custom projects for "NoEmbedding" exists for all supported platforms and executed by xharness. A sample `xcframework` with tests projects is also available [here](https://github.com/spouliot/xcframework). The xcframework test case is based on Rolf's earlier/partial implementation. https://github.com/rolfbjarne/xamarin-macios/commit/xcframework Things to note: Do not rename a framework (like XTest) to use it in an xcframework (like XCTest). That will fail at codesign but won't give anything useful. You might think signing the framework (instead of the inner binary) would solve it. It does, as it codesign, but then the app crash at startup. At some point you realize some symbols are still using XTest (not XCTest) and then you can delete several other weird workarounds (like for `ld`) because all of it was cause by this never identified rename. dSYM support (and tests) to be done in a separate PR.
2020-11-30 21:44:03 +03:00
<UsingTask TaskName="Xamarin.MacDev.Tasks.ResolveNativeReferences" AssemblyFile="$(_TaskAssemblyName)" />
[msbuild] Unify all the UsingTask statements. (#8998) Some of these have been duplicated across various targets files, and when adding a new task it's annoying to forget to add it somewhere. So just have them all in the same place, so that they're loaded in every file. There are still duplicates between the iOS and Mac tasks, but those will be unified in a later PR.
2020-07-07 16:52:06 +03:00
<UsingTask TaskName="Xamarin.MacDev.Tasks.SmartCopy" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.SpotlightIndexer" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.SymbolStrip" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.UnpackLibraryResources" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.WriteItemsToFile" AssemblyFile="$(_TaskAssemblyName)" />
<UsingTask TaskName="Xamarin.MacDev.Tasks.Zip" AssemblyFile="$(_TaskAssemblyName)" />
[msbuild] Add a GetMinimumOSVersion target that reads the app manifest and outputs the MinimumOSVersion. (#8858) This makes it possible for several other tasks to take the MinimumOSVersion as direct input, instead of the app manifest's path. Previously the app manifest (Info.plist) was loaded and parsed in each task, slightly differently in each place, and in addition there are differences between macOS and other platforms, which made it even worse. This code refactoring also made it possible to remove an error code which wasn't necessary anymore. This task also computes the default MinimumOSVersion if none is specified in the app manifest. There is one breaking change: a library project could previously specify an inexistent Info.plist, and it would build fine. This will now result in a "Error loading 'Info.plist': File not found" error. This is trivial to fix: just remove the Info.plist from the project file (or an alternative solution could be to condition the inclusion of the Info.plist in the project file on the existence of the Info.plist). New commits in xamarin/Xamarin.MacDev: * xamarin/Xamarin.MacDev@a1bc6f3 [Xamarin.MacDev] Split IAppleSdkVersion.TryParse in two methods. (#73) Diff: https://github.com/xamarin/Xamarin.MacDev/compare/45c5a680e20a209ac846a32e0f2f0f83e843ab76..a1bc6f39b3efe5d817c60d78eaff3f4c2de720ea
2020-06-16 18:40:04 +03:00
Add 'NoBindingEmbedding' style binding project support (#5167) - Existing binding projects embed the native libraries within the assembly as managed resource - This does not scale well and has performance implications - This PR creates a new property, NoBindingEmbedding which when true processes the building and consumption of binding projects differently. - Existing binding projects are not affected, they will continue as is - I've written a full XM test suite and ported a subset to iOS. Since iOS only supports checked in projects, and I didn't want to make the existing situation worse by adding more, I only wrote tests that could use the existing test projects. -When we complete some form of msbuild testing reform, we'll revisit these tests. - Remove two files in MyiOSFrameworkBinding that are not used (we use copies elsewhere) - Remove unnecessary sleep and fix broken touch command - Output failing test log to console instead of test output - VSfM does not handle thousands of lines of test failure message well - Add ability to generate binding projects with LinkWith
2018-12-12 17:55:57 +03:00
<Import Project="$(MSBuildThisFileDirectory)$(MSBuildThisFileName).Before.targets"
Condition="Exists('$(MSBuildThisFileDirectory)$(MSBuildThisFileName).Before.targets')"/>
<!--
@(NativeReference) are not safe to use as an Input to a task, as frameworks are a directory and will appears unbuilt every time.
So we split it into two camps as a prebuild step
-->
[msbuild] Add support for `.xcframework` (#10046) This is done early so we can resolve the inner framework, inside the xcframework, and let the existing framework support do most of the work. The resolving code has unit tests. Custom projects for "NoEmbedding" exists for all supported platforms and executed by xharness. A sample `xcframework` with tests projects is also available [here](https://github.com/spouliot/xcframework). The xcframework test case is based on Rolf's earlier/partial implementation. https://github.com/rolfbjarne/xamarin-macios/commit/xcframework Things to note: Do not rename a framework (like XTest) to use it in an xcframework (like XCTest). That will fail at codesign but won't give anything useful. You might think signing the framework (instead of the inner binary) would solve it. It does, as it codesign, but then the app crash at startup. At some point you realize some symbols are still using XTest (not XCTest) and then you can delete several other weird workarounds (like for `ld`) because all of it was cause by this never identified rename. dSYM support (and tests) to be done in a separate PR.
2020-11-30 21:44:03 +03:00
<Target Name="_ExpandNativeReferences" Condition="'$(DesignTimeBuild)' != 'true'" DependsOnTargets="_DetectSdkLocations;_ComputeTargetArchitectures">
Add 'NoBindingEmbedding' style binding project support (#5167) - Existing binding projects embed the native libraries within the assembly as managed resource - This does not scale well and has performance implications - This PR creates a new property, NoBindingEmbedding which when true processes the building and consumption of binding projects differently. - Existing binding projects are not affected, they will continue as is - I've written a full XM test suite and ported a subset to iOS. Since iOS only supports checked in projects, and I didn't want to make the existing situation worse by adding more, I only wrote tests that could use the existing test projects. -When we complete some form of msbuild testing reform, we'll revisit these tests. - Remove two files in MyiOSFrameworkBinding that are not used (we use copies elsewhere) - Remove unnecessary sleep and fix broken touch command - Output failing test log to console instead of test output - VSfM does not handle thousands of lines of test failure message well - Add ability to generate binding projects with LinkWith
2018-12-12 17:55:57 +03:00
<ItemGroup>
[msbuild] Add support for `.xcframework` (#10046) This is done early so we can resolve the inner framework, inside the xcframework, and let the existing framework support do most of the work. The resolving code has unit tests. Custom projects for "NoEmbedding" exists for all supported platforms and executed by xharness. A sample `xcframework` with tests projects is also available [here](https://github.com/spouliot/xcframework). The xcframework test case is based on Rolf's earlier/partial implementation. https://github.com/rolfbjarne/xamarin-macios/commit/xcframework Things to note: Do not rename a framework (like XTest) to use it in an xcframework (like XCTest). That will fail at codesign but won't give anything useful. You might think signing the framework (instead of the inner binary) would solve it. It does, as it codesign, but then the app crash at startup. At some point you realize some symbols are still using XTest (not XCTest) and then you can delete several other weird workarounds (like for `ld`) because all of it was cause by this never identified rename. dSYM support (and tests) to be done in a separate PR.
2020-11-30 21:44:03 +03:00
<_FrameworkNativeReference Include="@(NativeReference -> '%(Identity)/%(Filename)')" Condition="'%(Extension)' == '.framework' Or '%(Extension)' == '.xcframework'" />
<_FileNativeReference Include="@(NativeReference)" Condition="'%(Extension)' != '.framework' And '%(Extension)' != '.xcframework'" />
Add 'NoBindingEmbedding' style binding project support (#5167) - Existing binding projects embed the native libraries within the assembly as managed resource - This does not scale well and has performance implications - This PR creates a new property, NoBindingEmbedding which when true processes the building and consumption of binding projects differently. - Existing binding projects are not affected, they will continue as is - I've written a full XM test suite and ported a subset to iOS. Since iOS only supports checked in projects, and I didn't want to make the existing situation worse by adding more, I only wrote tests that could use the existing test projects. -When we complete some form of msbuild testing reform, we'll revisit these tests. - Remove two files in MyiOSFrameworkBinding that are not used (we use copies elsewhere) - Remove unnecessary sleep and fix broken touch command - Output failing test log to console instead of test output - VSfM does not handle thousands of lines of test failure message well - Add ability to generate binding projects with LinkWith
2018-12-12 17:55:57 +03:00
</ItemGroup>
[msbuild] Add support for `.xcframework` (#10046) This is done early so we can resolve the inner framework, inside the xcframework, and let the existing framework support do most of the work. The resolving code has unit tests. Custom projects for "NoEmbedding" exists for all supported platforms and executed by xharness. A sample `xcframework` with tests projects is also available [here](https://github.com/spouliot/xcframework). The xcframework test case is based on Rolf's earlier/partial implementation. https://github.com/rolfbjarne/xamarin-macios/commit/xcframework Things to note: Do not rename a framework (like XTest) to use it in an xcframework (like XCTest). That will fail at codesign but won't give anything useful. You might think signing the framework (instead of the inner binary) would solve it. It does, as it codesign, but then the app crash at startup. At some point you realize some symbols are still using XTest (not XCTest) and then you can delete several other weird workarounds (like for `ld`) because all of it was cause by this never identified rename. dSYM support (and tests) to be done in a separate PR.
2020-11-30 21:44:03 +03:00
<ResolveNativeReferences
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
Architectures="$(TargetArchitectures)"
NativeReferences="@(_FrameworkNativeReference)"
References="@(ReferencePath)"
SdkIsSimulator="$(_SdkIsSimulator)"
TargetFrameworkMoniker="$(_ComputedTargetFrameworkMoniker)"
>
<Output TaskParameter="NativeFrameworks" ItemName="_FrameworkNativeReference" />
</ResolveNativeReferences>
Add 'NoBindingEmbedding' style binding project support (#5167) - Existing binding projects embed the native libraries within the assembly as managed resource - This does not scale well and has performance implications - This PR creates a new property, NoBindingEmbedding which when true processes the building and consumption of binding projects differently. - Existing binding projects are not affected, they will continue as is - I've written a full XM test suite and ported a subset to iOS. Since iOS only supports checked in projects, and I didn't want to make the existing situation worse by adding more, I only wrote tests that could use the existing test projects. -When we complete some form of msbuild testing reform, we'll revisit these tests. - Remove two files in MyiOSFrameworkBinding that are not used (we use copies elsewhere) - Remove unnecessary sleep and fix broken touch command - Output failing test log to console instead of test output - VSfM does not handle thousands of lines of test failure message well - Add ability to generate binding projects with LinkWith
2018-12-12 17:55:57 +03:00
</Target>
<PropertyGroup>
<BindingResourcePath>$(ProjectDir)$(OutputPath)$(AssemblyName).resources</BindingResourcePath>
</PropertyGroup>
<Target Name="_CreateBindingResourcePackage" Condition="'$(DesignTimeBuild)' != 'true'"
DependsOnTargets="_ExpandNativeReferences"
Bump VSMac to 8.1.0.2742 to fix msbuild issues (#6279) * Bump VSMac to 8.1.0.2742 to fix msbuild issues This is required to get the support for the msbuild `ToolsVersion` change from `15.0` to `Current`. * [tests][msbuild] Fix Binding resources test with updated msbuild Test failure with updated msbuild and vsmac 8.1: ``` Xamarin.iOS.Tasks.NativeReferencesNoEmbedding("iPhone").ShouldNotUnnecessarilyRebuildBindingProject(True) Binding project build did not create package? Expected: True But was: False at Xamarin.iOS.Tasks.NativeReferencesNoEmbedding.ShouldNotUnnecessarilyRebuildBindingProject (System.Boolean framework) [0x000a0] in <74b8f7d8a53e40109916d305bb4d7403>:0 at (wrapper managed-to-native) System.Reflection.RuntimeMethodInfo.InternalInvoke(System.Reflection.RuntimeMethodInfo,object,object[],System.Exception&) at System.Reflection.RuntimeMethodInfo.Invoke (System.Object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, System.Object[] parameters, System.Globalization.CultureInfo cul ture) [0x0006a] in <0519fa732e8845b6a809ce9180f541db>:0 ``` The test builds the project multiple times. Before the 3rd build, the project file's timestamp is updated and expects that the binding package will be rebuilt. But it is not, because the target `_CreateBindingResourcePackage` doesn't depend on that project file. So, add that to the target inputs. * [nuget] Use xibuild to run nuget Fix errors seen during `nuget restore` for tests: ``` Users/builder/jenkins/workspace/xamarin-macios-pr-builder/tests/xammac_tests/xammac_tests.csproj(213,3): error MSB4024: The imported project file "/Library/Frameworks/Mono.framework/External/xbuild/Xamarin/Mac/Xamarin.Mac.CSharp.targets" could not be loaded. Could not find file "/Library/Frameworks/Mono.framework/External/xbuild/Xamarin/Mac/Xamarin.Mac.CSharp.targets" ```
2019-06-19 08:07:27 +03:00
Inputs="$(MSBuildAllProjects);$(MSBuildProjectFullPath);@(ObjcBindingApiDefinition);@(ObjcBindingCoreSource);@(ReferencePath);@(ObjcBindingNativeLibrary);@(_FrameworkNativeReference);@(_FileNativeReference)"
Add 'NoBindingEmbedding' style binding project support (#5167) - Existing binding projects embed the native libraries within the assembly as managed resource - This does not scale well and has performance implications - This PR creates a new property, NoBindingEmbedding which when true processes the building and consumption of binding projects differently. - Existing binding projects are not affected, they will continue as is - I've written a full XM test suite and ported a subset to iOS. Since iOS only supports checked in projects, and I didn't want to make the existing situation worse by adding more, I only wrote tests that could use the existing test projects. -When we complete some form of msbuild testing reform, we'll revisit these tests. - Remove two files in MyiOSFrameworkBinding that are not used (we use copies elsewhere) - Remove unnecessary sleep and fix broken touch command - Output failing test log to console instead of test output - VSfM does not handle thousands of lines of test failure message well - Add ability to generate binding projects with LinkWith
2018-12-12 17:55:57 +03:00
Outputs="$(BindingResourcePath)/manifest">
<CreateBindingResourcePackage Condition="'$(IsMacEnabled)' == 'true' And '$(NoBindingEmbedding)' == 'true' And '$(SkipBindingResourcePackage)' != 'true'"
SessionId="$(BuildSessionId)"
OutputPath="$(OutputPath)"
NativeReferences="@(NativeReference)"
ProjectDir="$(MSBuildProjectDirectory)"
BindingAssembly="@(IntermediateAssembly)">
<Output TaskParameter="Manifest" ItemName="_BundleResourceManifest" />
</CreateBindingResourcePackage>
</Target>
<!-- Cleaning via FileWrites leaves empty framework directories on disk, so nuke via RemoveDir -->
<PropertyGroup>
<CleanDependsOn>
$(CleanDependsOn);
_CleanBindingResourcePackage
</CleanDependsOn>
</PropertyGroup>
<Target Name="_CleanBindingResourcePackage">
<RemoveDir Directories="$(BindingResourcePath);" />
</Target>
[msbuild] Don't include System.Drawing.Common.dll when building using net5. There's no System.Drawing.Common.dll in net5.
2020-05-26 14:42:30 +03:00
<Target Name="_AddExtraReferences" BeforeTargets="ResolveAssemblyReferences" Condition="'$(DisableExtraReferences)' != 'true' And '$(_UsingXamarinSdk)' != 'true'">
[msbuild] add System.Drawing.Common ref for bindings (#8528) Fixes: https://github.com/xamarin/xamarin-macios/issues/8265 Usage of `System.Drawing` types in iOS binding projects are failing with: error CS1069: The type name 'Color' could not be found in the namespace 'System.Drawing'. This type has been forwarded to assembly 'System.Drawing.Common, Version=4.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51' Consider adding a reference to that assembly. In 3a7bdc0, an `_AddExtraReferences` MSBuild target was added for iOS and Mac projects, but mistakenly missing from binding projects. I moved the `_AddExtraReferences` target to `Xamarin.Shared.targets`, so it will be used for all project types. I also updated a test, I could merely use `System.Drawing.Color` in `StructsAndEnums.cs` to reproduce the failure.
2020-05-07 23:27:06 +03:00
<ItemGroup>
<!-- https://github.com/mono/mono/issues/13483 -->
<Reference Include="System.Drawing.Common.dll" />
</ItemGroup>
</Target>
[msbuild] Share the MSBuild logic for CollectBundleResources and a few related properties. (#8983) * [msbuild] Share the MSBuild logic for CollectBundleResources and a few related properties. * [msbuild] Fix/unify more resource collection code. * Remove the _CollectBundleResources target for Xamarin.iOS binding projects, we now have a single one for all project types. * Add an IsBindingProject property to distinguish binding projects from other projects. * Use the IsBindingProject to only depend on the other _Compile<ResourceType> targets when we're not building a binding project (which seems to be the reason why the _CollectBundleResources target was duplicated between normal projects and binding projects for both Xamarin.iOS and Xamarin.Mac: the binding project version didn't have any dependencies).
2020-07-01 21:13:05 +03:00
<PropertyGroup Condition="'$(IsBindingProject)' != 'true'">
<_CollectBundleResourcesDependsOn>
_CompileImageAssets;
_CompileInterfaceDefinitions;
_CompileSceneKitAssets;
_CompileColladaAssets;
_CompileTextureAtlases;
[msbuild] Share the *CompileCoreMLModels targets between Xamarin.iOS and Xamarin.Mac. (#9792) Xamarin.Mac didn't have support for CoreML models before, so this effectively adds support for CoreML models to Xamarin.Mac. Also add a test to make sure it actually works.
2020-10-07 09:42:17 +03:00
_CompileCoreMLModels;
[msbuild] Share the MSBuild logic for CollectBundleResources and a few related properties. (#8983) * [msbuild] Share the MSBuild logic for CollectBundleResources and a few related properties. * [msbuild] Fix/unify more resource collection code. * Remove the _CollectBundleResources target for Xamarin.iOS binding projects, we now have a single one for all project types. * Add an IsBindingProject property to distinguish binding projects from other projects. * Use the IsBindingProject to only depend on the other _Compile<ResourceType> targets when we're not building a binding project (which seems to be the reason why the _CollectBundleResources target was duplicated between normal projects and binding projects for both Xamarin.iOS and Xamarin.Mac: the binding project version didn't have any dependencies).
2020-07-01 21:13:05 +03:00
$(_CollectBundleResourcesDependsOn);
</_CollectBundleResourcesDependsOn>
</PropertyGroup>
<Target Name="_CollectBundleResources" DependsOnTargets="$(_CollectBundleResourcesDependsOn)">
<CollectBundleResources
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
OptimizePropertyLists="$(OptimizePropertyLists)"
OptimizePNGs="$(OptimizePNGs)"
BundleResources="@(Content);@(BundleResource)"
ProjectDir="$(MSBuildProjectDirectory)"
ResourcePrefix="$(_ResourcePrefix)"
>
<Output TaskParameter="BundleResourcesWithLogicalNames" ItemName="_BundleResourceWithLogicalName" />
</CollectBundleResources>
</Target>
[msbuild] Unify the CompileAppManifest target. (#8875) Also rework the class hierarchy a little bit, so that Xamarin.iOS and Xamarin.Mac are identical: CompileAppManifestTaskBase └─── iOS/CompileAppManifestTaskCore │ └─── iOS/CompileAppManifest └─── Mac/CompileAppManifestTaskCore │ └─── Mac/CompileAppManifest
2020-06-18 16:46:45 +03:00
<PropertyGroup>
<_CompileAppManifestDependsOn>
$(_CompileAppManifestDependsOn);
_DetectSdkLocations;
_GetMinimumOSVersion;
_GenerateBundleName;
_DetectSigningIdentity;
_ComputeTargetFrameworkMoniker;
</_CompileAppManifestDependsOn>
</PropertyGroup>
<Target Name="_CompileAppManifest"
DependsOnTargets="$(_CompileAppManifestDependsOn)"
Inputs="$(_AppManifest);@(_PartialAppManifest)"
Outputs="$(_AppBundlePath)$(_AppBundleManifestRelativePath)Info.plist" >
<CompileAppManifest
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
AppBundleName="$(_AppBundleName)"
AppManifest="$(_AppManifest)"
AppManifestBundleDirectory="$(_AppBundlePath)$(_AppBundleManifestRelativePath)"
AssemblyName="$(AssemblyName)"
BundleIdentifier="$(_BundleIdentifier)"
Debug="$(_BundlerDebug)"
DefaultSdkVersion="$(_SdkVersion)"
IsAppExtension="$(IsAppExtension)"
IsWatchApp="$(IsWatchApp)"
IsWatchExtension="$(IsWatchExtension)"
IsXPCService="$(IsXPCService)"
MinimumOSVersion="$(_MinimumOSVersion)"
PartialAppManifests="@(_PartialAppManifest)"
ResourceRules="$(_PreparedResourceRules)"
TargetArchitectures="$(TargetArchitectures)"
TargetFrameworkMoniker="$(_ComputedTargetFrameworkMoniker)"
SdkPlatform="$(_SdkPlatform)"
SdkIsSimulator="$(_SdkIsSimulator)"
DebugIPAddresses="$(_DebugIPAddresses)"
>
</CompileAppManifest>
<RemoveDir SessionId="$(BuildSessionId)" Condition="'$(IsMacEnabled)' == 'true'" Directories="$(AppBundleDir).dSYM" />
<Delete SessionId="$(BuildSessionId)" Condition="'$(IsMacEnabled)' == 'true'" Files="$(DeviceSpecificOutputPath)*.bcsymbolmap" />
</Target>
[msbuild] Share the _CompileEntitlements target. (#9323) Use two separate output variables (EntitlementsInExecutable/EntitlementsInSignature) instead of using the same output variable for two different purposes. This makes the code more self-explanatory. Also move the simulator check to the C# code, that way it's easier to re-use elsewhere. * [msbuild] Share the _CompileEntitlements task. * [msbuild] Create the same class hierarchy for Xamarin.Mac and Xamarin.iOS for the CompileEntitlements task. CompileEntitlementsTaskBase └─── iOS/CompileEntitlementsTaskCore │ └─── iOS/CompileEntitlements └─── Mac/CompileEntitlementsTaskCore └─── Mac/CompileEntitlements This also means we can remove a known failure in the list of MSBuild tasks that don't conform to our 'no code in final task implementation' requirements.
2020-08-10 14:55:54 +03:00
<PropertyGroup>
<_CompileEntitlementsDependsOn>
$(_CompileEntitlementsDependsOn);
_DetectSdkLocations;
_GenerateBundleName;
_DetectSigningIdentity;
_ComputeTargetFrameworkMoniker;
</_CompileEntitlementsDependsOn>
</PropertyGroup>
<Target Name="_CompileEntitlements"
Condition="'$(_RequireCodeSigning)' == 'true' Or ('$(CodesignEntitlements)' != '' And '$(_PlatformName)' != 'macOS')"
DependsOnTargets="$(_CompileEntitlementsDependsOn)"
Outputs="$(DeviceSpecificIntermediateOutputPath)Entitlements.xcent">
<CompileEntitlements
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
AppBundleDir="$(AppBundleDir)"
AppIdentifier="$(_AppIdentifier)"
BundleIdentifier="$(_BundleIdentifier)"
Entitlements="$(CodesignEntitlements)"
CompiledEntitlements="$(DeviceSpecificIntermediateOutputPath)Entitlements.xcent"
IsAppExtension="$(IsAppExtension)"
ProvisioningProfile="$(_ProvisioningProfile)"
SdkIsSimulator="$(_SdkIsSimulator)"
SdkPlatform="$(_SdkPlatform)"
SdkVersion="$(_SdkVersion)"
SdkDevPath="$(_SdkDevPath)"
TargetFrameworkMoniker="$(_ComputedTargetFrameworkMoniker)"
Debug="$(_BundlerDebug)"
>
<!-- $(_CompiledEntitlements) will be passed to the MTouch task, it's used to embed the entitlements in the executable -->
<Output TaskParameter="EntitlementsInExecutable" PropertyName="_CompiledEntitlements" />
<!-- $(_CompiledCodesignEntitlements) will be used only with Codesign tasks when building for device. MUST NOT BE SET for iOS Simulator builds. -->
<Output TaskParameter="EntitlementsInSignature" PropertyName="_CompiledCodesignEntitlements" />
</CompileEntitlements>
</Target>
[msbuild] Share the _*CompileInterfaceDefinitions targets between Xamarin.iOS and Xamarin.Mac. (#9708) The Xamarin.iOS version seemed more updated, so that's the version now for both Xamarin.iOS and Xamarin.Mac. A few differences in the Xamarin.iOS versions are: * The _CoreCompileInterfaceDefinitions target contains Inputs/Outputs (important for incremental builds). * EnableOnDemandResources is set to $(EnableOnDemandResources), not hardcoded to 'false' (there is no real difference right now, because $(EnableOnDemandResources) defaults to 'false' in Xamarin.Mac). * It doesn't use FileWrites (see e97d69b25cc2b85e89feb775169f46f467c66f7a why this was removed for iOS)
2020-09-28 10:17:50 +03:00
<Target Name="_CompileInterfaceDefinitions" DependsOnTargets="_DetectAppManifest;_DetectSdkLocations;_ComputeTargetArchitectures;_BeforeCoreCompileInterfaceDefinitions;_ReadCoreCompileInterfaceDefinitions;_CoreCompileInterfaceDefinitions" />
<Target Name="_BeforeCoreCompileInterfaceDefinitions"
Inputs="@(InterfaceDefinition)"
Outputs="$(_IBToolCache)">
<!-- If any InterfaceDefinition is newer than the generated items list, we delete them so that the _CoreCompileInterfaceDefinitions
target runs again and updates those lists for the next run
-->
<Delete Files="$(_IBToolCache)" />
</Target>
<Target Name="_ReadCoreCompileInterfaceDefinitions" DependsOnTargets="_BeforeCoreCompileInterfaceDefinitions">
<!-- If _BeforeCoreCompileInterfaceDefinitions did not delete the generated items lists from _CoreCompileInterfaceDefinitions, then we read them
since that target won't run and we need to the output items that are cached in those files which includes full metadata -->
<ReadItemsFromFile File="$(_IBToolCache)" Condition="Exists('$(_IBToolCache)')">
<Output TaskParameter="Items" ItemName="_BundleResourceWithLogicalName" />
</ReadItemsFromFile>
</Target>
<Target Name="_CoreCompileInterfaceDefinitions"
Inputs="@(InterfaceDefinition)"
Outputs="$(_IBToolCache)"
DependsOnTargets="_BeforeCoreCompileInterfaceDefinitions;_GetMinimumOSVersion">
<IBTool
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
ToolExe="$(IBToolExe)"
ToolPath="$(IBToolPath)"
AppManifest="$(_AppManifest)"
EnableOnDemandResources="$(EnableOnDemandResources)"
InterfaceDefinitions="@(InterfaceDefinition)"
IntermediateOutputPath="$(DeviceSpecificIntermediateOutputPath)"
MinimumOSVersion="$(_MinimumOSVersion)"
IsWatchApp="$(IsWatchApp)"
IsWatch2App="$(IsWatch2App)"
ProjectDir="$(MSBuildProjectDirectory)"
ResourcePrefix="$(_ResourcePrefix)"
SdkDevPath="$(_SdkDevPath)"
SdkBinPath="$(_SdkBinPath)"
SdkUsrPath="$(_SdkUsrPath)"
SdkRoot="$(_SdkRoot)"
SdkPlatform="$(_SdkPlatform)"
SdkVersion="$(_SdkVersion)">
<Output TaskParameter="BundleResources" ItemName="_BundleResourceWithLogicalName" />
<!-- Local items to be persisted to items files -->
<Output TaskParameter="BundleResources" ItemName="_IBTool_BundleResources" />
</IBTool>
<!-- Cached the generated outputs items for incremental build support -->
<WriteItemsToFile Items="@(_IBTool_BundleResources)" ItemName="_BundleResourceWithLogicalName" File="$(_IBToolCache)" Overwrite="true" IncludeMetadata="true" />
<ItemGroup>
<FileWrites Include="$(_IBToolCache)" />
</ItemGroup>
</Target>
[msbuild] Share the _*CompileSceneKitAssets targets between Xamarin.iOS and Xamarin.Mac. (#9735) The Xamarin.iOS version is more updated, so that's the version now for both Xamarin.iOS and Xamarin.Mac: * The iOS version contains Inputs/Outputs (important for incremental builds). * It doesn't use FileWrites (see e97d69b25cc2b85e89feb775169f46f467c66f7a why this was removed for iOS) Additionally define the _SceneKitCache variable for macOS as well, previously it was only defined for iOS (I'm adding more variables than just _SceneKitCache to macOS, most of the others will be used in in macOS in upcoming pull requests, and this way turned out to be simplest). And also add a new Xamarin.Mac test that exercises the CompileSceneKitAssets targets.
2020-10-01 09:37:52 +03:00
<Target Name="_CompileSceneKitAssets" DependsOnTargets="_DetectAppManifest;_DetectSdkLocations;_ComputeTargetArchitectures;_BeforeCoreCompileSceneKitAssets;_ReadCoreCompileSceneKitAssets;_CoreCompileSceneKitAssets" />
<Target Name="_BeforeCoreCompileSceneKitAssets"
Inputs="@(SceneKitAsset)"
Outputs="$(_SceneKitCache)">
<!-- If any SceneKitAsset is newer than the generated items list, we delete them so that the _CoreCompileSceneKitAssets
target runs again and updates those lists for the next run
-->
<Delete Files="$(_SceneKitCache)" />
</Target>
<Target Name="_ReadCoreCompileSceneKitAssets"
DependsOnTargets="_BeforeCoreCompileSceneKitAssets">
<!-- If _BeforeCoreCompileSceneKitAssets did not delete the generated items lists from _CoreCompileSceneKitAssets, then we read them
since that target won't run and we need to the output items that are cached in those files which includes full metadata -->
<ReadItemsFromFile File="$(_SceneKitCache)" Condition="Exists('$(_SceneKitCache)')">
<Output TaskParameter="Items" ItemName="_BundleResourceWithLogicalName" />
</ReadItemsFromFile>
</Target>
<Target Name="_CoreCompileSceneKitAssets"
Inputs="@(SceneKitAsset)"
Outputs="$(_SceneKitCache)"
DependsOnTargets="_BeforeCoreCompileSceneKitAssets;_GenerateBundleName;_ComputeTargetFrameworkMoniker">
<CompileSceneKitAssets
SessionId="$(BuildSessionId)"
AppBundleName="$(_AppBundleName)$(AppBundleExtension)"
Condition="'$(IsMacEnabled)' == 'true'"
ToolExe="$(CopySceneKitAssetsExe)"
ToolPath="$(CopySceneKitAssetsPath)"
SceneKitAssets="@(SceneKitAsset)"
IntermediateOutputPath="$(DeviceSpecificIntermediateOutputPath)"
TargetFrameworkMoniker="$(_ComputedTargetFrameworkMoniker)"
ProjectDir="$(MSBuildProjectDirectory)"
ResourcePrefix="$(_ResourcePrefix)"
IsWatchApp="$(IsWatchApp)"
SdkPlatform="$(_SdkPlatform)"
SdkDevPath="$(_SdkDevPath)"
SdkRoot="$(_SdkRoot)"
SdkVersion="$(_SdkVersion)">
<Output TaskParameter="BundleResources" ItemName="_BundleResourceWithLogicalName" />
<!-- Local items to be persisted to items files -->
<Output TaskParameter="BundleResources" ItemName="_SceneKitAssets_BundleResources" />
</CompileSceneKitAssets>
<WriteItemsToFile Items="@(_SceneKitAssets_BundleResources)" ItemName="_BundleResourceWithLogicalName" File="$(_SceneKitCache)" Overwrite="true" IncludeMetadata="true" />
<ItemGroup>
<FileWrites Include="$(_SceneKitCache)" />
</ItemGroup>
</Target>
[msbuild] Share targets related to Collada assets. (#10050)
2020-11-05 17:10:19 +03:00
<!-- Collada assets -->
<PropertyGroup>
<CompileColladaAssetsDependsOn>
_CollectColladaAssets;
_CoreCompileColladaAssets
</CompileColladaAssetsDependsOn>
</PropertyGroup>
<Target Name="_CompileColladaAssets" Condition="'$(_CanOutputAppBundle)' == 'true'" DependsOnTargets="$(CompileColladaAssetsDependsOn)" />
<Target Name="_CollectColladaAssets">
<CollectBundleResources
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
BundleResources="@(Collada)"
ProjectDir="$(MSBuildProjectDirectory)"
ResourcePrefix="$(_ResourcePrefix)">
<Output TaskParameter="BundleResourcesWithLogicalNames" ItemName="_ColladaAssetWithLogicalName" />
</CollectBundleResources>
</Target>
<Target Name="_CoreCompileColladaAssets"
DependsOnTargets="_CollectColladaAssets;_DetectSdkLocations;_ComputeTargetFrameworkMoniker"
Inputs="@(_ColladaAssetWithLogicalName)"
Outputs="$(DeviceSpecificIntermediateOutputPath)%(_ColladaAssetWithLogicalName.LogicalName)"
>
<ScnTool
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
ToolExe="$(ScnToolExe)"
ToolPath="$(ScnToolPath)"
SdkRoot="$(_SdkRoot)"
SdkDevPath="$(_SdkDevPath)"
SdkVersion="$(_SdkVersion)"
TargetFrameworkMoniker="$(_ComputedTargetFrameworkMoniker)"
IntermediateOutputPath="$(DeviceSpecificIntermediateOutputPath)"
InputScene="%(_ColladaAssetWithLogicalName.Identity)"
OutputScene="$(DeviceSpecificIntermediateOutputPath)%(_ColladaAssetWithLogicalName.LogicalName)">
</ScnTool>
<CreateItem Include="$(DeviceSpecificIntermediateOutputPath)%(_ColladaAssetWithLogicalName.LogicalName)" AdditionalMetadata="LogicalName=%(_ColladaAssetWithLogicalName.LogicalName);Optimize='False'">
<Output TaskParameter="Include" ItemName="_BundleResourceWithLogicalName" />
</CreateItem>
</Target>
[msbuild] Share _ComputeTargetArchitectures and use the output variables for both Xamarin.iOS and Xamarin.Mac. (#8751)
2020-06-04 16:00:28 +03:00
<Target Name="_ComputeTargetArchitectures" DependsOnTargets="_ComputeTargetFrameworkMoniker">
<!--
For now, this target is mostly for Xamarin.iOS, but in order to
use the same variables elsewhere, we have code for Xamarin.Mac
that outputs the same variables. However, as build logic between
Xamarin.iOS and Xamarin.Mac converges, more and more of this logic
will apply to Xamarin.Mac as well.
-->
<ParseDeviceSpecificBuildInformation
SessionId="$(BuildSessionId)"
Condition="'$(DeviceSpecificBuild)' == 'true' And '$(TargetiOSDevice)' != '' And '$(_CanDeployToDeviceOrSimulator)' == 'true' And '$(_PlatformName)' != 'macOS'"
[msbuild] Unify MtouchArch and XamMacArch into TargetArchitectures. (#8797) * [msbuild] Unify MtouchArch and XamMacArch into TargetArchitectures. * [msbuild] Use $(ComputedPlatform) instead of $(_Platform). They're identical, and this avoids using $(_Platform) before it's defined.
2020-06-09 15:28:36 +03:00
Architectures="$(TargetArchitectures)"
[msbuild] Share _ComputeTargetArchitectures and use the output variables for both Xamarin.iOS and Xamarin.Mac. (#8751)
2020-06-04 16:00:28 +03:00
IntermediateOutputPath="$(IntermediateOutputPath)"
OutputPath="$(OutputPath)"
TargetFrameworkMoniker="$(_ComputedTargetFrameworkMoniker)"
TargetiOSDevice="$(TargetiOSDevice)"
>
<Output TaskParameter="DeviceSpecificIntermediateOutputPath" PropertyName="DeviceSpecificIntermediateOutputPath" />
<Output TaskParameter="DeviceSpecificOutputPath" PropertyName="DeviceSpecificOutputPath" />
<Output TaskParameter="TargetArchitectures" PropertyName="TargetArchitectures" />
<Output TaskParameter="TargetDeviceModel" PropertyName="TargetDeviceModel" />
<Output TaskParameter="TargetDeviceOSVersion" PropertyName="TargetDeviceOSVersion" />
</ParseDeviceSpecificBuildInformation>
[msbuild] Share the _*CompileSceneKitAssets targets between Xamarin.iOS and Xamarin.Mac. (#9735) The Xamarin.iOS version is more updated, so that's the version now for both Xamarin.iOS and Xamarin.Mac: * The iOS version contains Inputs/Outputs (important for incremental builds). * It doesn't use FileWrites (see e97d69b25cc2b85e89feb775169f46f467c66f7a why this was removed for iOS) Additionally define the _SceneKitCache variable for macOS as well, previously it was only defined for iOS (I'm adding more variables than just _SceneKitCache to macOS, most of the others will be used in in macOS in upcoming pull requests, and this way turned out to be simplest). And also add a new Xamarin.Mac test that exercises the CompileSceneKitAssets targets.
2020-10-01 09:37:52 +03:00
<PropertyGroup>
[msbuild] Share _ComputeTargetArchitectures and use the output variables for both Xamarin.iOS and Xamarin.Mac. (#8751)
2020-06-04 16:00:28 +03:00
<_MtouchSymbolsList>$(DeviceSpecificIntermediateOutputPath)mtouch-symbols.list</_MtouchSymbolsList>
<!-- actool output caches -->
<_ACTool_PartialAppManifestCache>$(DeviceSpecificIntermediateOutputPath)actool\_PartialAppManifest.items</_ACTool_PartialAppManifestCache>
<_ACTool_BundleResourceCache>$(DeviceSpecificIntermediateOutputPath)actool\_BundleResourceWithLogicalName.items</_ACTool_BundleResourceCache>
<!-- coremlc output caches -->
<_CoreMLModel_PartialAppManifestCache>$(DeviceSpecificIntermediateOutputPath)coremlc\_PartialAppManifest.items</_CoreMLModel_PartialAppManifestCache>
<_CoreMLModel_BundleResourceCache>$(DeviceSpecificIntermediateOutputPath)coremlc\_BundleResourceWithLogicalName.items</_CoreMLModel_BundleResourceCache>
<!-- ibtool output caches -->
<_IBToolCache>$(DeviceSpecificIntermediateOutputPath)ibtool\_BundleResourceWithLogicalName.items</_IBToolCache>
<!-- scntool output caches -->
<_SceneKitCache>$(DeviceSpecificIntermediateOutputPath)copySceneKitAssets\_BundleResourceWithLogicalName.items</_SceneKitCache>
<!-- TextureAtlas output caches -->
<_TextureAtlasCache>$(DeviceSpecificIntermediateOutputPath)atlas\_BundleResourceWithLogicalName.items</_TextureAtlasCache>
</PropertyGroup>
</Target>
[msbuild] Unify the logic to copy bundle resources to the app. (#8987) * For Xamarin.Mac, this means using the _ComputeBundleResourceOutputPaths and _CopyResourcesToBundle targets from Xamarin.iOS instead of the _CopyContentToBundle target (which is now unused and thus removed). * Adapt the Xamarin.iOS logic (now shared) to handle the fact that the resources shouldn't always go into the root appbundle directory (since they go into Contents/Resources/ for macOS apps), by using the '_AppResourcesPath' variable to specify just this. Once upon a time the Xamarin.iOS logic was identical to the Xamarin.Mac logic, but then we implemented support for asset packs (https://github.com/xamarin/maccore/commit/a98693f07e3f7675773e1f371392c05ff178d3d4) and the code diverged. This means that unifying the logic again is a step towards making asset packs work for Xamarin.Mac apps.
2020-07-03 12:00:36 +03:00
<!-- TODO: check for duplicate items -->
<Target Name="_ComputeBundleResourceOutputPaths" DependsOnTargets="_CollectBundleResources;_GenerateBundleName;_DetectSigningIdentity">
<ComputeBundleResourceOutputPaths
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
AppResourcesPath="$(_AppResourcesPath)"
BundleIdentifier="$(_BundleIdentifier)"
BundleResources="@(_BundleResourceWithLogicalName)"
EnableOnDemandResources="$(EnableOnDemandResources)"
IntermediateOutputPath="$(DeviceSpecificIntermediateOutputPath)"
OutputPath="$(DeviceSpecificOutputPath)"
>
<Output TaskParameter="BundleResourcesWithOutputPaths" ItemName="_BundleResourceWithOutputPath"/>
</ComputeBundleResourceOutputPaths>
</Target>
<Target Name="_CopyResourcesToBundle" DependsOnTargets="_ComputeBundleResourceOutputPaths"
Inputs = "@(_BundleResourceWithOutputPath)"
Outputs = "@(_BundleResourceWithOutputPath -> '%(OutputPath)')" >
<SmartCopy
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
SourceFiles = "@(_BundleResourceWithOutputPath)"
DestinationFiles = "@(_BundleResourceWithOutputPath -> '%(OutputPath)')"
/>
</Target>
[msbuild] Share the _CreateAppBundle task between Xamarin.Mac and Xamarin.iOS. (#8694) There is a difference for Xamarin.Mac: the task will not be executed anymore if IsAppDistribution is set to true. Given that IsAppDistribution is not used in Xamarin.Mac projects, this is likely a rather uncommon case, and the potential for breaking behavior is outweighed by the advantage of having the same behavior for Xamarin.iOS and Xamarin.Mac.
2020-05-28 09:34:11 +03:00
<Target Name="_CreateAppBundle" Condition="'$(_CanOutputAppBundle)' == 'true' And '$(IsAppDistribution)' != 'true'" DependsOnTargets="$(CreateAppBundleDependsOn)" />
[msbuild] Share the _CreatePkgInfo target between Xamarin.iOS and Xamarin.Mac. (#9770) The Xamarin.Mac version of _CreatePkgInfo had a 'Ditto' call that seemed like a copy-paste error (the target below has the exac same call to 'Ditto'), and there's no reason to call 'Ditto' when creating the PkgInfo file, so I just removed it. The 'Ditto' call was added here: https://github.com/xamarin/xamarin-macios/commit/ca028ea15022ac0358fc1e31b3b8c2e0997eaf8e#diff-ccded350e40e767d69171655acb86b01R586-R606
2020-10-05 09:55:35 +03:00
<Target Name="_ComputePkgInfoPath" DependsOnTargets="_GenerateBundleName">
<PropertyGroup>
<_PkgInfoPath Condition="'$(_PlatformName)' == 'macOS'">$(_AppBundlePath)Contents\PkgInfo</_PkgInfoPath>
<_PkgInfoPath Condition="'$(_PlatformName)' != 'macOS'">$(_AppBundlePath)PkgInfo</_PkgInfoPath>
</PropertyGroup>
</Target>
<Target Name="_CreatePkgInfo" Condition="'$(IsAppExtension)' == 'false'" DependsOnTargets="_ComputePkgInfoPath" Outputs="$(_PkgInfoPath)">
<CreatePkgInfo SessionId="$(BuildSessionId)" Condition="'$(IsMacEnabled)' == 'true'" OutputPath="$(_PkgInfoPath)" />
</Target>
[msbuild] Share the *CompileCoreMLModels targets between Xamarin.iOS and Xamarin.Mac. (#9792) Xamarin.Mac didn't have support for CoreML models before, so this effectively adds support for CoreML models to Xamarin.Mac. Also add a test to make sure it actually works.
2020-10-07 09:42:17 +03:00
<Target Name="_CompileCoreMLModels" DependsOnTargets="_DetectAppManifest;_DetectSdkLocations;_ComputeTargetArchitectures;_BeforeCompileCoreMLModels;_ReadCompileCoreMLModels;_CoreCompileCoreMLModels" />
<Target Name="_BeforeCompileCoreMLModels"
Inputs="@(CoreMLModel);$(_AppManifest)"
Outputs="$(_CoreMLModel_PartialAppManifestCache);$(_CoreMLModel_BundleResourceCache)">
<!-- If any CoreMLModel or AppManifest is newer than the generated items list, we delete them so that the _CoreCompileCoreMLModels
target runs again and updates those lists for the next run
-->
<Delete Files="$(_CoreMLModel_PartialAppManifestCache);$(_CoreMLModel_BundleResourceCache)" />
<RemoveDir Directories="$(DeviceSpecificIntermediateOutputPath)coremlc" />
</Target>
<Target Name="_ReadCompileCoreMLModels" DependsOnTargets="_BeforeCompileCoreMLModels">
<!-- If _BeforeCompileCoreMLModels did not delete the generated items lists from _CoreCompileCoreMLModels, then we read them
since that target won't run and we need the output items that are cached in those files, which includes full metadata -->
<ReadItemsFromFile File="$(_CoreMLModel_PartialAppManifestCache)" Condition="Exists('$(_CoreMLModel_PartialAppManifestCache)')">
<Output TaskParameter="Items" ItemName="_PartialAppManifest" />
</ReadItemsFromFile>
<ReadItemsFromFile File="$(_CoreMLModel_BundleResourceCache)" Condition="Exists('$(_CoreMLModel_BundleResourceCache)')">
<Output TaskParameter="Items" ItemName="_BundleResourceWithLogicalName" />
</ReadItemsFromFile>
</Target>
<Target Name="_CoreCompileCoreMLModels"
Inputs="@(CoreMLModel);$(_AppManifest)"
Outputs="$(_CoreMLModel_PartialAppManifestCache);$(_CoreMLModel_BundleResourceCache)"
DependsOnTargets="_DetectAppManifest;_DetectSdkLocations;_BeforeCompileCoreMLModels">
<CoreMLCompiler
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
ToolExe="$(CoreMLCompilerExe)"
ToolPath="$(CoreMLCompilerPath)"
Models="@(CoreMLModel)"
EnableOnDemandResources="$(EnableOnDemandResources)"
IntermediateOutputPath="$(DeviceSpecificIntermediateOutputPath)"
ProjectDir="$(MSBuildProjectDirectory)"
ResourcePrefix="$(_ResourcePrefix)"
SdkDevPath="$(_SdkDevPath)">
<Output TaskParameter="BundleResources" ItemName="_BundleResourceWithLogicalName" />
<Output TaskParameter="PartialAppManifests" ItemName="_PartialAppManifest" />
<!-- Local items to be persisted to items files -->
<Output TaskParameter="PartialAppManifests" ItemName="_CoreMLModel_PartialAppManifest" />
<Output TaskParameter="BundleResources" ItemName="_CoreMLModel_BundleResources" />
</CoreMLCompiler>
<!-- Cache the generated outputs items for incremental build support -->
<WriteItemsToFile Items="@(_CoreMLModel_PartialAppManifest)" ItemName="_PartialAppManifest" File="$(_CoreMLModel_PartialAppManifestCache)" Overwrite="true" IncludeMetadata="true" />
<WriteItemsToFile Items="@(_CoreMLModel_BundleResources)" ItemName="_BundleResourceWithLogicalName" File="$(_CoreMLModel_BundleResourceCache)" Overwrite="true" IncludeMetadata="true" />
<ItemGroup>
<FileWrites Include="$(_CoreMLModel_PartialAppManifestCache);$(_CoreMLModel_BundleResourceCache)" />
</ItemGroup>
</Target>
[msbuild] Share the _*Metal tasks between Xamarin.iOS and Xamarin.Mac. (#9786) * This fixes a bug in the Xamarin.Mac version, where the _ForgeMetal's Outputs value didn't match the actual output path (this was fixed in the iOS version). * Also update the definition of the _ForgedMetal itemgroup to use a nested ItemGroup instead of the CreateItem task.
2020-10-06 15:17:56 +03:00
<Target Name="_SmeltMetal" Condition="'$(_CanOutputAppBundle)' == 'true' And '@(Metal)' != ''" DependsOnTargets="_DetectSdkLocations;_ComputeTargetFrameworkMoniker;_GetMinimumOSVersion">
<Metal
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true' and '%(Metal.Identity)' != ''"
IntermediateOutputPath="$(DeviceSpecificIntermediateOutputPath)"
MinimumOSVersion="$(_MinimumOSVersion)"
ProjectDir="$(MSBuildProjectDirectory)"
TargetFrameworkMoniker="$(_ComputedTargetFrameworkMoniker)"
ResourcePrefix="$(_ResourcePrefix)"
SdkDevPath="$(_SdkDevPath)"
SdkIsSimulator="$(_SdkIsSimulator)"
SdkRoot="$(_SdkRoot)"
SdkVersion="$(_SdkVersion)"
SourceFile="@(Metal)">
<Output TaskParameter="OutputFile" ItemName="_SmeltedMetal" />
</Metal>
</Target>
<Target Name="_ForgeMetal" Condition="'$(_CanOutputAppBundle)' == 'true' And '@(_SmeltedMetal)' != ''" DependsOnTargets="_SmeltMetal"
Inputs="@(_SmeltedMetal)" Outputs="$(DeviceSpeficicIntermediateOutputPath)metal\default.metal-ar">
<ArTool
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true' and '$(_IsXcode8)' == 'false'"
Items="@(_SmeltedMetal)"
Archive="$(DeviceSpecificIntermediateOutputPath)metal\default.metal-ar">
</ArTool>
<ItemGroup>
<_ForgedMetal Condition="'$(_IsXcode8)' == 'false'" Include="$(DeviceSpecificIntermediateOutputPath)metal\default.metal-ar" />
<_ForgedMetal Condition="'$(_IsXcode8)' == 'true'" Include="@(_SmeltedMetal)" />
</ItemGroup>
</Target>
<Target Name="_TemperMetal" Condition="'$(_CanOutputAppBundle)' == 'true' And '@(_ForgedMetal)' != ''" DependsOnTargets="_ForgeMetal;_GenerateBundleName"
Inputs="@(_ForgedMetal)" Outputs="$(_AppResourcesPath)default.metallib">
<MetalLib
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
Items="@(_ForgedMetal)"
SdkDevPath="$(_SdkDevPath)"
SdkRoot="$(_SdkRoot)"
OutputLibrary="$(_AppResourcesPath)default.metallib">
</MetalLib>
</Target>
[msbuild] Unify the _DetectAppManifest target. (#8745) There's one difference for Xamarin.Mac library projects: they'll now have the ability to use an Info.plist to specify a minimum OS version that will be used when compiling storyboards and other compilable files. This is the way it's worked for Xamarin.iOS projects for a long time.
2020-06-04 10:14:58 +03:00
<Target Name="_DetectAppManifest">
<!--
This targets runs for Library projects as well, so that Library
projects can specify an Info.plist with MinimumOSVersion to pass
to actool, ibtool, and other Xcode tools.
Ref: https://bugzilla.xamarin.com/show_bug.cgi?id=34736
-->
<FindItemWithLogicalName
SessionId="$(BuildSessionId)"
ProjectDir="$(MSBuildProjectDirectory)"
ResourcePrefix="$(_ResourcePrefix)"
LogicalName="Info.plist"
Items="@(None)">
<Output TaskParameter="Item" PropertyName="_AppManifest" />
</FindItemWithLogicalName>
<FindItemWithLogicalName Condition="'$(_AppManifest)' == '' And '$(_CanOutputAppBundle)' == 'true'"
SessionId="$(BuildSessionId)"
ProjectDir="$(MSBuildProjectDirectory)"
ResourcePrefix="$(_ResourcePrefix)"
LogicalName="Info.plist"
Items="@(BundleResource)">
<Output TaskParameter="Item" PropertyName="_AppManifest" />
</FindItemWithLogicalName>
<FindItemWithLogicalName Condition="'$(_AppManifest)' == '' And '$(_CanOutputAppBundle)' == 'true'"
SessionId="$(BuildSessionId)"
ProjectDir="$(MSBuildProjectDirectory)"
ResourcePrefix="$(_ResourcePrefix)"
LogicalName="Info.plist"
Items="@(Content)">
<Output TaskParameter="Item" PropertyName="_AppManifest" />
</FindItemWithLogicalName>
<Error Condition="'$(_AppManifest)' == '' And '$(_CanOutputAppBundle)' == 'true'" Text="Info.plist not found."/>
</Target>
[msbuild] Unify the _GenerateBindings target and a few properties related to binding projects. (#8997)
2020-07-07 16:46:23 +03:00
<PropertyGroup Condition="'$(IsBindingProject)' == 'true'">
<!-- Add our own pre and post build steps -->
<!-- Override the CoreCompile Target to use bgen -->
<CompileDependsOn>
_GenerateBindings;
_PrepareNativeReferences;
_CollectGeneratedSources;
$(CompileDependsOn)
_CreateBindingResourcePackage;
</CompileDependsOn>
</PropertyGroup>
[msbuild] Create a few '_*DependsOn' variables that specifies depend targets. (#9305) The .NET logic will inject an additional dependencies in these variables.
2020-08-07 15:53:49 +03:00
<PropertyGroup>
<_GenerateBindingsDependsOn>
_ComputeTargetFrameworkMoniker;
$(_GenerateBindingsDependsOn);
</_GenerateBindingsDependsOn>
</PropertyGroup>
[msbuild] Unify the _GenerateBindings target and a few properties related to binding projects. (#8997)
2020-07-07 16:46:23 +03:00
<Target Name="_GenerateBindings"
Inputs="$(MSBuildAllProjects);@(ObjcBindingApiDefinition);@(ObjcBindingCoreSource);@(ReferencePath);@(ObjcBindingNativeLibrary)"
Outputs="$(_GeneratedSourcesFileList)"
[msbuild] Create a few '_*DependsOn' variables that specifies depend targets. (#9305) The .NET logic will inject an additional dependencies in these variables.
2020-08-07 15:53:49 +03:00
DependsOnTargets="$(_GenerateBindingsDependsOn)"
[msbuild] Unify the _GenerateBindings target and a few properties related to binding projects. (#8997)
2020-07-07 16:46:23 +03:00
Condition="'$(IsBindingProject)' == 'true' And '$(DesignTimeBuild)' != 'true'">
<ItemGroup>
<BTouchReferencePath Include="@(ReferenceCopyLocalPaths)" Condition="'%(Extension)' == '.dll'" />
</ItemGroup>
<PropertyGroup>
<BTouchEmitDebugInformation>false</BTouchEmitDebugInformation>
<BTouchEmitDebugInformation Condition="'$(Debug)' != ''">true</BTouchEmitDebugInformation>
</PropertyGroup>
[msbuild] Create the output directory for generated binding sources.
2020-07-17 17:38:40 +03:00
<MakeDir SessionId="$(BuildSessionId)" Condition="'$(IsMacEnabled)' == 'true'" Directories="$(GeneratedSourcesDir)" />
[msbuild] Unify the _GenerateBindings target and a few properties related to binding projects. (#8997)
2020-07-07 16:46:23 +03:00
<BTouch
Condition="'$(IsMacEnabled)' == 'true'"
SessionId="$(BuildSessionId)"
OutputPath="$(OutputPath)"
ObjectiveCLibraries="@(ObjcBindingNativeLibrary)"
AdditionalLibPaths="$(AdditionalLibPaths)"
AllowUnsafeBlocks="$(AllowUnsafeBlocks)"
ApiDefinitions="@(ObjcBindingApiDefinition)"
[msbuild] Pass the path to the binding attribute assembly to bgen.
2020-07-17 17:38:40 +03:00
AttributeAssembly="$(_GeneratorAttributeAssembly)"
[msbuild] Unify the _GenerateBindings target and a few properties related to binding projects. (#8997)
2020-07-07 16:46:23 +03:00
BaseLibDll="$(BaseLibDllPath)"
CoreSources="@(ObjcBindingCoreSource)"
DefineConstants="$(DefineConstants)"
EmitDebugInformation="$(BTouchEmitDebugInformation)"
ExtraArgs="$(BTouchExtraArgs)"
GeneratedSourcesDir="$(GeneratedSourcesDir)"
GeneratedSourcesFileList="$(_GeneratedSourcesFileList)"
Namespace="$(Namespace)"
OutputAssembly="$(OutputAssembly)"
ProcessEnums="$(ProcessEnums)"
ProjectDir="$(MSBuildProjectDirectory)"
References="@(ReferencePath);@(BTouchReferencePath)"
TargetFrameworkMoniker="$(_ComputedTargetFrameworkMoniker)"
BTouchToolPath="$(BTouchToolPath)"
BTouchToolExe="$(BTouchToolExe)"
StandardOutputImportance="High"
>
</BTouch>
</Target>
[msbuild] Add a GetMinimumOSVersion target that reads the app manifest and outputs the MinimumOSVersion. (#8858) This makes it possible for several other tasks to take the MinimumOSVersion as direct input, instead of the app manifest's path. Previously the app manifest (Info.plist) was loaded and parsed in each task, slightly differently in each place, and in addition there are differences between macOS and other platforms, which made it even worse. This code refactoring also made it possible to remove an error code which wasn't necessary anymore. This task also computes the default MinimumOSVersion if none is specified in the app manifest. There is one breaking change: a library project could previously specify an inexistent Info.plist, and it would build fine. This will now result in a "Error loading 'Info.plist': File not found" error. This is trivial to fix: just remove the Info.plist from the project file (or an alternative solution could be to condition the inclusion of the Info.plist in the project file on the existence of the Info.plist). New commits in xamarin/Xamarin.MacDev: * xamarin/Xamarin.MacDev@a1bc6f3 [Xamarin.MacDev] Split IAppleSdkVersion.TryParse in two methods. (#73) Diff: https://github.com/xamarin/Xamarin.MacDev/compare/45c5a680e20a209ac846a32e0f2f0f83e843ab76..a1bc6f39b3efe5d817c60d78eaff3f4c2de720ea
2020-06-16 18:40:04 +03:00
<Target Name="_GetMinimumOSVersion" DependsOnTargets="_DetectAppManifest;_DetectSdkLocations;_ComputeTargetFrameworkMoniker">
<GetMinimumOSVersion
[msbuild] Avoids running GetMinimumOSVersion if no Mac is connected (#9144) `GetMinimumOSVersion` should not be run if there's no Mac available because it depends on `_DetectSdkLocations` to calculate the value of `_SdkVersion`, and this will only happen if there's a Mac connected. This change fixes offline builds (plain IL builds) and Hot Restart builds on Windows. Co-authored-by: emaf <ema@xamarin.com>
2020-07-22 09:27:14 +03:00
Condition="'$(IsMacEnabled)' == 'true'"
[msbuild] Add a GetMinimumOSVersion target that reads the app manifest and outputs the MinimumOSVersion. (#8858) This makes it possible for several other tasks to take the MinimumOSVersion as direct input, instead of the app manifest's path. Previously the app manifest (Info.plist) was loaded and parsed in each task, slightly differently in each place, and in addition there are differences between macOS and other platforms, which made it even worse. This code refactoring also made it possible to remove an error code which wasn't necessary anymore. This task also computes the default MinimumOSVersion if none is specified in the app manifest. There is one breaking change: a library project could previously specify an inexistent Info.plist, and it would build fine. This will now result in a "Error loading 'Info.plist': File not found" error. This is trivial to fix: just remove the Info.plist from the project file (or an alternative solution could be to condition the inclusion of the Info.plist in the project file on the existence of the Info.plist). New commits in xamarin/Xamarin.MacDev: * xamarin/Xamarin.MacDev@a1bc6f3 [Xamarin.MacDev] Split IAppleSdkVersion.TryParse in two methods. (#73) Diff: https://github.com/xamarin/Xamarin.MacDev/compare/45c5a680e20a209ac846a32e0f2f0f83e843ab76..a1bc6f39b3efe5d817c60d78eaff3f4c2de720ea
2020-06-16 18:40:04 +03:00
SessionId="$(BuildSessionId)"
AppManifest="$(_AppManifest)"
SdkVersion="$(_SdkVersion)"
TargetFrameworkMoniker="$(_ComputedTargetFrameworkMoniker)"
>
<Output TaskParameter="MinimumOSVersion" PropertyName="_MinimumOSVersion" />
</GetMinimumOSVersion>
</Target>
[msbuild] Share the _DetectSigningIdentity target. (#8785) Also rework the class hierarchy a little bit, so that Xamarin.iOS and Xamarin.Mac are identical: DetectSigningIdentityTaskBase └─── iOS/DetectSigningIdentityTaskCore │ └─── iOS/DetectSigningIdentity └─── Mac/DetectSigningIdentityTaskCore │ └─── Mac/DetectSigningIdentity
2020-06-08 09:58:59 +03:00
<Target Name="_DetectSigningIdentity" Condition="'$(_CanOutputAppBundle)' == 'true'" DependsOnTargets="_DetectAppManifest;_DetectSdkLocations;_ComputeTargetFrameworkMoniker">
<DetectSigningIdentity
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
AppBundleName="$(_AppBundleName)"
AppManifest="$(_AppManifest)"
Keychain="$(CodesignKeychain)"
RequireCodeSigning="$(_RequireCodeSigning)"
RequireProvisioningProfile="$(_RequireProvisioningProfile)"
SdkIsSimulator="$(_SdkIsSimulator)"
SdkPlatform="$(_SdkPlatform)"
ProvisioningProfile="$(CodesignProvision)"
SigningKey="$(_SpecifiedCodesignKey)"
DetectedCodeSigningKey="$(_CodeSigningKey)"
TargetFrameworkMoniker="$(_ComputedTargetFrameworkMoniker)"
>
<Output TaskParameter="DetectedAppId" PropertyName="_AppIdentifier" />
<Output TaskParameter="DetectedBundleId" PropertyName="_BundleIdentifier" />
<Output TaskParameter="DetectedBundleVersion" PropertyName="_BundleVersion" />
<Output TaskParameter="DetectedCodeSigningKey" PropertyName="_CodeSigningKey" />
<Output TaskParameter="DetectedCodesignAllocate" PropertyName="_CodesignAllocate" />
<Output TaskParameter="DetectedDistributionType" PropertyName="_DistributionType" />
<Output TaskParameter="DetectedProvisioningProfile" PropertyName="_ProvisioningProfile" />
</DetectSigningIdentity>
</Target>
[msbuild] Share the _DetectSdkLocations target. (#8755)
2020-06-05 18:08:02 +03:00
<Target Name="_DetectSdkLocations" DependsOnTargets="_ComputeTargetArchitectures;_ComputeTargetFrameworkMoniker">
<DetectSdkLocations
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
SdkVersion="$(_SdkVersion)"
TargetFrameworkMoniker="$(_ComputedTargetFrameworkMoniker)"
TargetArchitectures="$(TargetArchitectures)"
>
<Output TaskParameter="SdkVersion" PropertyName="_SdkVersion" />
<Output TaskParameter="SdkRoot" PropertyName="_SdkRoot" />
<Output TaskParameter="SdkBinPath" PropertyName="_SdkBinPath" />
<Output TaskParameter="SdkDevPath" PropertyName="_SdkDevPath" />
<Output TaskParameter="SdkUsrPath" PropertyName="_SdkUsrPath" />
<Output TaskParameter="SdkPlatform" PropertyName="_SdkPlatform" />
<Output TaskParameter="SdkIsSimulator" PropertyName="_SdkIsSimulator" />
<Output TaskParameter="IsXcode8" PropertyName="_IsXcode8" />
<Output TaskParameter="XamarinSdkRoot" PropertyName="_XamarinSdkRoot" />
</DetectSdkLocations>
</Target>
[msbuild] Share the Pack/UnpackLibraryResources targets between Xamarin.iOS and Xamarin.Mac. (#9471) There were 2 differences that had to be reconciled: * The Xamarin.Mac version took 'IntermediateOutputPath' as the intermediate output path, while the Xamarin.iOS version used 'DeviceSpecificIntermediateOutputPath'. 'DeviceSpecificIntermediateOutputPath' is defined to be 'IntermediateOutputPath' for Xamarin.Mac, so make the shared version use 'DeviceSpecificIntermediateOutputPath', since that works in both cases. * The Xamarin.Mac version was writing the output of PackLibraryResources to the FileWrites item group. This was removed on purpose from the Xamarin.iOS version in e97d69b25cc2b85e89feb775169f46f467c66f7a, so it seemed best to leave it out in the shared version as well. Also re-use the _EmbeddedResourcePrefix variable to determine the resource prefix.
2020-08-25 11:42:33 +03:00
<Target Name="_PackLibraryResources" Condition="'$(_CanOutputAppBundle)' == 'false'" DependsOnTargets="_CollectBundleResources">
<PackLibraryResources
Condition="'$(IsMacEnabled)' == 'true'"
SessionId="$(BuildSessionId)"
Prefix="$(_EmbeddedResourcePrefix)"
BundleResourcesWithLogicalNames="@(_BundleResourceWithLogicalName)">
<Output TaskParameter="EmbeddedResources" ItemName="EmbeddedResource" />
</PackLibraryResources>
</Target>
<Target Name="_UnpackLibraryResources" Condition="'$(_CanOutputAppBundle)' == 'true'" DependsOnTargets="ResolveReferences;_CollectBundleResources">
<UnpackLibraryResources
Condition="'$(IsMacEnabled)' == 'true'"
SessionId="$(BuildSessionId)"
Prefix="$(_EmbeddedResourcePrefix)"
NoOverwrite="@(_BundleResourceWithLogicalName)"
IntermediateOutputPath="$(DeviceSpecificIntermediateOutputPath)"
TargetFrameworkDirectory="$(TargetFrameworkDirectory)"
ReferencedLibraries="@(ReferencePath);@(ReferenceDependencyPaths)">
<Output TaskParameter="BundleResourcesWithLogicalNames" ItemName="_BundleResourceWithLogicalName" />
</UnpackLibraryResources>
</Target>
[msbuild] Make the ParseExtraMtouchArgs task platform-agnostic, and share it between Xamarin.iOS and Xamarin.Mac. (#9061) * Change the parsing code slightly, to make it easier to parse other arguments (coming soon). * Add the parsing task to Xamarin.Mac projects, and use it there as well. The parsed result isn't used yet, but it will be soon. * Unify a few related MSBuild properties (MtouchNoSymbolStrip and MtouchNoDSymUtil).
2020-07-13 15:56:34 +03:00
<Target Name="_ParseBundlerArguments">
<ParseBundlerArguments
ExtraArgs="$(_BundlerArguments)"
NoSymbolStrip="$(_NoSymbolStrip)"
NoDSymUtil="$(_NoDSymUtil)"
>
[msbuild] Use the ParseBundlerArguments task to parse mmp's --custom_bundle_name argument. (#9709)
2020-09-29 09:42:28 +03:00
<Output TaskParameter="CustomBundleName" ItemName="_CustomBundleName" />
[msbuild] Parse --marshal-managed-exceptions and --marshal-objectivec-exceptions in ParseBundlerArgumentsTask. (#9493) Also add some tests.
2020-08-26 20:03:45 +03:00
<Output TaskParameter="MarshalManagedExceptionMode" PropertyName="_MarshalManagedExceptionMode" />
<Output TaskParameter="MarshalObjectiveCExceptionMode" PropertyName="_MarshalObjectiveCExceptionMode" />
[msbuild] Make the ParseExtraMtouchArgs task platform-agnostic, and share it between Xamarin.iOS and Xamarin.Mac. (#9061) * Change the parsing code slightly, to make it easier to parse other arguments (coming soon). * Add the parsing task to Xamarin.Mac projects, and use it there as well. The parsed result isn't used yet, but it will be soon. * Unify a few related MSBuild properties (MtouchNoSymbolStrip and MtouchNoDSymUtil).
2020-07-13 15:56:34 +03:00
<Output TaskParameter="NoSymbolStrip" PropertyName="_NoSymbolStrip"/>
<Output TaskParameter="NoDSymUtil" PropertyName="_NoDSymUtil"/>
[msbuild] Parse the --optimize extra bundler arguments in ParseBundlerArgumentsTask. (#9572) Also add some tests.
2020-09-02 16:05:31 +03:00
<Output TaskParameter="Optimize" PropertyName="_BundlerOptimize"/>
[msbuild] Parse the --registrar extra bundler argument in ParseBundlerArgumentsTask. (#9606) Also add some tests.
2020-09-09 16:42:33 +03:00
<Output TaskParameter="Registrar" PropertyName="_BundlerRegistrar" />
[dotnet] Add Verbosity to the linker configuration. (#9169)
2020-07-23 19:07:05 +03:00
<Output TaskParameter="Verbosity" PropertyName="_BundlerVerbosity" />
[msbuild] Parse the --xml extra bundler argument in ParseBundlerArgumentsTask. (#9639) Also add some tests.
2020-09-16 10:42:21 +03:00
<Output TaskParameter="XmlDefinitions" ItemName="_BundlerXmlDefinitions" />
[msbuild] Make the ParseExtraMtouchArgs task platform-agnostic, and share it between Xamarin.iOS and Xamarin.Mac. (#9061) * Change the parsing code slightly, to make it easier to parse other arguments (coming soon). * Add the parsing task to Xamarin.Mac projects, and use it there as well. The parsed result isn't used yet, but it will be soon. * Unify a few related MSBuild properties (MtouchNoSymbolStrip and MtouchNoDSymUtil).
2020-07-13 15:56:34 +03:00
</ParseBundlerArguments>
[msbuild] Use the ParseBundlerArguments task to parse mmp's --custom_bundle_name argument. (#9709)
2020-09-29 09:42:28 +03:00
<PropertyGroup>
<_CustomBundleName Condition="'$(_CustomBundleName)' == ''">MonoBundle</_CustomBundleName>
</PropertyGroup>
[msbuild] Make the ParseExtraMtouchArgs task platform-agnostic, and share it between Xamarin.iOS and Xamarin.Mac. (#9061) * Change the parsing code slightly, to make it easier to parse other arguments (coming soon). * Add the parsing task to Xamarin.Mac projects, and use it there as well. The parsed result isn't used yet, but it will be soon. * Unify a few related MSBuild properties (MtouchNoSymbolStrip and MtouchNoDSymUtil).
2020-07-13 15:56:34 +03:00
</Target>
[msbuild] Share some of the code signing targets between Xamarin.Mac and Xamarin.iOS. (#8710)
2020-06-01 11:23:17 +03:00
<!-- Code signing -->
<PropertyGroup>
<CoreCodesignDependsOn>
$(CoreCodesignDependsOn);
_CodesignAppBundle;
_CodesignVerify;
</CoreCodesignDependsOn>
<CodesignDependsOn>
$(CodesignDependsOn);
BeforeCodeSign;
CoreCodeSign;
AfterCodeSign;
</CodesignDependsOn>
</PropertyGroup>
<Target Name="BeforeCodesign" />
<Target Name="CoreCodesign" DependsOnTargets="$(CoreCodesignDependsOn)" />
<Target Name="AfterCodesign" />
<Target Name="Codesign" Condition="'$(_CanOutputAppBundle)' == 'true'" DependsOnTargets="$(CodesignDependsOn)" />
[msbuild] Share the CodesignNativeLibraries target between Xamarin.iOS and Xamarin.Mac. (#9775)
2020-10-06 15:18:31 +03:00
<PropertyGroup>
<_CodesignNativeLibrariesDependsOn>
$(_CodesignNativeLibrariesDependsOn);
_DetectSigningIdentity;
_CompileToNative;
</_CodesignNativeLibrariesDependsOn>
</PropertyGroup>
<!-- Note:
Always codesign *.dylibs even for Simulator builds for iOS/tvOS/watchOS. We use $(_CanOutputAppBundle) because dylibs can exist in app extensions as well.
For macOS we sign if _RequireCodeSigning is true
-->
<Target Name="_CodesignNativeLibraries" Condition="'$(_CanOutputAppBundle)' == 'true' And ('$(_RequireCodeSigning)' == 'true' Or '$(_PlatformName)' != 'macOS')" DependsOnTargets="$(_CodesignNativeLibrariesDependsOn)">
<PropertyGroup>
<_CodesignDisableTimestamp>False</_CodesignDisableTimestamp>
<_CodesignDisableTimestamp Condition="'$(_SdkIsSimulator)' == 'true' Or '$(_BundlerDebug)' == 'true'">True</_CodesignDisableTimestamp>
<_LibraryCodeSigningKey>$(_CodeSigningKey)</_LibraryCodeSigningKey>
<_LibraryCodeSigningKey Condition="'$(_LibraryCodeSigningKey)' == ''">-</_LibraryCodeSigningKey>
</PropertyGroup>
<ItemGroup Condition="'$(_PlatformName)' == 'macOS'">
<_CodesignNativeLibrary Include="$(_AppContentsPath)\**\*.dylib" />
<_CodesignNativeLibrary Include="$(_AppResourcesPath)\**\*.metallib" />
</ItemGroup>
<ItemGroup Condition="'$(_PlatformName)' != 'macOS'">
<_CodesignNativeLibrary
Include="$(_AppBundlePath)\**\*.dylib;$(_AppBundlePath)\**\*.metallib"
Exclude="$(_AppBundlePath)\Watch\**;$(_AppBundlePath)\PlugIns\**"
/>
</ItemGroup>
<Codesign
Condition="'$(IsMacEnabled)' == 'true'"
SessionId="$(BuildSessionId)"
CodesignAllocate="$(_CodesignAllocate)"
DisableTimestamp="$(_CodesignDisableTimestamp)"
ExtraArgs="$(CodesignExtraArgs)"
IsAppExtension="$(IsAppExtension)"
Keychain="$(CodesignKeychain)"
Resources="@(_CodesignNativeLibrary)"
SigningKey="$(_LibraryCodeSigningKey)"
StampPath="$(DeviceSpecificIntermediateOutputPath)codesign\"
ToolExe="$(CodesignExe)"
ToolPath="$(CodesignPath)"
UseSecureTimestamp="$(UseHardenedRuntime)"
>
</Codesign>
</Target>
[mac] Add user-framework support for Xamarin.Mac (#10144) * Move existing tests to iOS subdirectory and adjust reference paths
2020-11-26 16:47:41 +03:00
<PropertyGroup>
<_CollectFrameworksDependsOn>
$(_CollectFrameworksDependsOn);
_CompileToNative;
</_CollectFrameworksDependsOn>
</PropertyGroup>
<Target Name="_CollectFrameworks" Condition="'$(_CanOutputAppBundle)' == 'true'" DependsOnTargets="$(_CollectFrameworksDependsOn)">
<PropertyGroup>
<_FrameworksDirectory Condition="'$(_PlatformName)' != 'macOS'">$(_AppBundlePath)/Frameworks</_FrameworksDirectory>
<_FrameworksDirectory Condition="'$(_PlatformName)' == 'macOS'">$(_AppBundlePath)/Contents/Frameworks</_FrameworksDirectory>
</PropertyGroup>
<CollectFrameworks
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
FrameworksDirectory="$(_FrameworksDirectory)"
>
<Output TaskParameter="Frameworks" ItemName="_Frameworks"/>
</CollectFrameworks>
</Target>
<Target Name="_CodesignFrameworks" Condition="'$(_CanOutputAppBundle)' == 'true' And '@(_Frameworks)' != ''" DependsOnTargets="_DetectSigningIdentity;_CollectFrameworks"
Inputs="%(_Frameworks.Identity)" Outputs="$(DeviceSpecificIntermediateOutputPath)codesign\%(_Frameworks.Filename)%(_Frameworks.Extension)">
<PropertyGroup>
<_CodesignDisableTimestamp>False</_CodesignDisableTimestamp>
<_CodesignDisableTimestamp Condition="'$(_SdkIsSimulator)' == 'true' Or '$(_BundlerDebug)' == 'true'">True</_CodesignDisableTimestamp>
<_FrameworkCodeSigningKey>$(_CodeSigningKey)</_FrameworkCodeSigningKey>
<_FrameworkCodeSigningKey Condition="'$(_FrameworkCodeSigningKey)' == ''">-</_FrameworkCodeSigningKey>
</PropertyGroup>
<Codesign
Condition="'$(IsMacEnabled)' == 'true'"
SessionId="$(BuildSessionId)"
ToolExe="$(CodesignExe)"
ToolPath="$(CodesignPath)"
CodesignAllocate="$(_CodesignAllocate)"
DisableTimestamp="$(_CodesignDisableTimestamp)"
Keychain="$(CodesignKeychain)"
Resources="@(_Frameworks)"
SigningKey="$(_FrameworkCodeSigningKey)"
ExtraArgs="$(CodesignExtraArgs)"
>
</Codesign>
<MakeDir SessionId="$(BuildSessionId)" Condition="'$(IsMacEnabled)' == 'true'" Directories="$(DeviceSpecificIntermediateOutputPath)codesign" />
<Touch
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
AlwaysCreate="true"
Files="$(DeviceSpecificIntermediateOutputPath)codesign\%(_Frameworks.Filename)%(_Frameworks.Extension)"
>
<Output TaskParameter="TouchedFiles" ItemName="FileWrites" />
</Touch>
</Target>
[dotnet] Turn the linker off by default for simulator builds. (#9403) This becomes a bit complicated because we have to wait to determine the default value for the linker until we know if we're building for the simulator or not (which happens in the _DetectSdkLocations target).
2020-08-20 15:26:43 +03:00
<!-- LinkMode -->
<PropertyGroup>
<_ComputeLinkModeDependsOn>
$(_ComputeLinkModeDependsOn);
_DetectSdkLocations;
</_ComputeLinkModeDependsOn>
</PropertyGroup>
<Target Name="_ComputeLinkMode" DependsOnTargets="$(_ComputeLinkModeDependsOn)">
<PropertyGroup>
<_LinkMode Condition="'$(_LinkMode)' == '' And '$(_PlatformName)' == 'macOS'">$(LinkMode)</_LinkMode>
<_LinkMode Condition="'$(_LinkMode)' == '' And '$(_PlatformName)' != 'macOS'">$(MtouchLink)</_LinkMode>
<_LinkMode Condition="'$(_LinkMode)' == ''">$(_DefaultLinkMode)</_LinkMode> <!-- Let the .NET targets chime in -->
<_LinkMode Condition="'$(_LinkMode)' == '' And '$(_PlatformName)' == 'macOS'">None</_LinkMode> <!-- Linking is off by default for macOS apps -->
<_LinkMode Condition="'$(_LinkMode)' == '' And '$(_PlatformName)' != 'macOS'">SdkOnly</_LinkMode> <!-- Default linking is SdkOnly for iOS/tvOS/watchOS apps -->
</PropertyGroup>
</Target>
Add support for arbitrary extensions to be bundled in XI/XM apps (#9048) - This commit adds a hook, "AdditionalAppExtensions", to the msbuild to allow extensions written in other languages, such as Swift, to be embedded and signed in an Xamarin App bundle easily. - Example: <AdditionalAppExtensions Include="$(MSBuildProjectDirectory)/../../native"> <Name>NativeTodayExtension</Name> <BuildOutput Condition="'$(Platform)' == 'iPhone'">build/Debug-iphoneos</BuildOutput> <BuildOutput Condition="'$(Platform)' == 'iPhoneSimulator'">build/Debug-iphonesimulator</BuildOutput> </AdditionalAppExtensions>
2020-07-16 18:13:15 +03:00
<Target Name="_ExtendAppExtensionReferences" DependsOnTargets="_ResolveAppExtensionReferences" Condition=" '@(AdditionalAppExtensions)' != ''">
<!-- The idea here is that after _ResolveAppExtensionReferences we inject the 3rd party extensions into the list being processed later for embedding and code signing.
- _ResolvedAppExtensionReferences is an item group of the path, so that's easy.
- _AppExtensionCodesignProperties less so. It is generated by reading codesign.items generated by the c# tasks during build, which we don't have.
We also don't have a concrete list of types that get serialized, so I dug for every property referenced and set what I believe are sane values.-->
<ItemGroup>
<_ResolvedAppExtensionReferences Include="%(AdditionalAppExtensions.Identity)/%(AdditionalAppExtensions.BuildOutput)/%(AdditionalAppExtensions.Name).appex" />
<_AppExtensionCodesignProperties Include="%(AdditionalAppExtensions.Name).appex">
Fixed issue with code signing when using multiple AdditionalAppExtensions (#9846)
2020-10-21 17:27:45 +03:00
<Entitlements Condition="Exists('%(AdditionalAppExtensions.Identity)/%(AdditionalAppExtensions.Name).entitlements')">%(AdditionalAppExtensions.Identity)/%(AdditionalAppExtensions.Name).entitlements</Entitlements>
Add support for arbitrary extensions to be bundled in XI/XM apps (#9048) - This commit adds a hook, "AdditionalAppExtensions", to the msbuild to allow extensions written in other languages, such as Swift, to be embedded and signed in an Xamarin App bundle easily. - Example: <AdditionalAppExtensions Include="$(MSBuildProjectDirectory)/../../native"> <Name>NativeTodayExtension</Name> <BuildOutput Condition="'$(Platform)' == 'iPhone'">build/Debug-iphoneos</BuildOutput> <BuildOutput Condition="'$(Platform)' == 'iPhoneSimulator'">build/Debug-iphonesimulator</BuildOutput> </AdditionalAppExtensions>
2020-07-16 18:13:15 +03:00
<SigningKey>$(CodesignKey)</SigningKey>
<Keychain>$(CodesignKeychain)</Keychain>
<DisableTimestamp>False</DisableTimestamp>
<DisableTimestamp Condition="'$(_SdkIsSimulator)' == 'true' Or '$(_BundlerDebug)' == 'true'">True</DisableTimestamp>
<CodesignAllocate>$(_CodesignAllocate)</CodesignAllocate>
<ResourceRules>$(CodesignResourceRules)</ResourceRules>
<NativeExecutable>%(AdditionalAppExtensions.Filename)</NativeExecutable>
</_AppExtensionCodesignProperties>
</ItemGroup>
</Target>
[msbuild] Move Xamarin.iOS' implementation of the PrepareResourceRules task to Xamarin.MacDev.Tasks. (#9318)
2020-08-07 15:54:38 +03:00
<Target Name="_PrepareResourceRules" DependsOnTargets="_DetectSdkLocations;_GenerateBundleName">
<PrepareResourceRules
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true' And '$(CodesignResourceRules)' != '' And '$(ComputedPlatform)' == 'iPhone'"
AppBundleDir="$(AppBundleDir)"
ResourceRules="$(CodesignResourceRules)"
SdkVersion="$(_SdkVersion)"
>
<Output TaskParameter="PreparedResourceRules" PropertyName="_PreparedResourceRules"/>
</PrepareResourceRules>
</Target>
[msbuild] Share the app extensions targets between iOS and Mac. (#10039) * Share the following targets: * _ResolveAppExtensionReferences * _SplitAppExtensionReferencesByExistent * _AssignAppExtensionConfiguration * _SeparateAppExtensionReferences * _CopyAppExtensionsToBundle The first four were pretty much identical between iOS and Mac already, and needed very few changes. The latter, _CopyAppExtensionsToBundle, required a little bit of tweaking to the targets to make sure it works for both iOS and Mac: * Removed the conditions on the Ditto task to check if we have app extensions - this is unnecessary because Inputs/Outputs on the target itself (which weren't there when the Ditto task conditions were written). * Added a '_PlaceAppExtensions' target that calculates where in the container's app bundle extensions should be placed (the '_AppExtensionRoot' property), and the name of the containing folder (the 'ContainerName' metadata).
2020-11-04 17:39:02 +03:00
<!-- App extensions -->
<Target Name="_AssignAppExtensionConfiguration" Condition="'@(_AppExtensionReference)' != ''">
<!-- assign configs if building a solution file -->
<AssignProjectConfiguration
ProjectReferences = "@(_AppExtensionReference)"
SolutionConfigurationContents = "$(CurrentSolutionConfigurationContents)"
Condition="'$(CurrentSolutionConfigurationContents)' != ''">
<Output TaskParameter="AssignedProjects" ItemName="_AppExtensionReferenceWithConfiguration"/>
</AssignProjectConfiguration>
<!-- Else, just -->
<CreateItem Include="@(_AppExtensionReference)"
Condition="'$(CurrentSolutionConfigurationContents)' == ''">
<Output TaskParameter="Include" ItemName="_AppExtensionReferenceWithConfiguration"/>
</CreateItem>
</Target>
<Target Name="_SeparateAppExtensionReferences" BeforeTargets="AssignProjectConfiguration">
<CreateItem Include="@(ProjectReference)" PreserveExistingMetadata="true" Condition="'%(Identity)' != '' And '%(ProjectReference.IsAppExtension)' == 'true'">
<Output ItemName="_AppExtensionReference" TaskParameter="Include" />
</CreateItem>
<ItemGroup>
<ProjectReference Remove="@(_AppExtensionReference)" />
</ItemGroup>
</Target>
<!-- Split App Extension projects into 2 lists
_AppExtensionReferenceWithConfigurationExistent: Projects existent on disk
_AppExtensionReferenceWithConfigurationNonExistent: Projects non-existent on disk -->
<Target Name="_SplitAppExtensionReferencesByExistent" DependsOnTargets="_AssignAppExtensionConfiguration">
<CreateItem Include="@(_AppExtensionReferenceWithConfiguration)" Condition="'@(_AppExtensionReferenceWithConfiguration)' != ''">
<Output TaskParameter="Include" ItemName="_AppExtensionReferenceWithConfigurationExistent"
Condition="Exists ('%(_AppExtensionReferenceWithConfiguration.Identity)')"/>
<Output TaskParameter="Include" ItemName="_AppExtensionReferenceWithConfigurationNonExistent"
Condition="!Exists ('%(_AppExtensionReferenceWithConfiguration.Identity)')"/>
</CreateItem>
</Target>
<Target Name="_ResolveAppExtensionReferences" DependsOnTargets="_SplitAppExtensionReferencesByExistent">
<PropertyGroup>
<!-- When building a .sln with msbuild, the dependent projects may not be built. So, always build
the referenced projects unless building from IDE. -->
<_BuildReferencedExtensionProjects Condition="'$(BuildingInsideVisualStudio)' != 'true'">true</_BuildReferencedExtensionProjects>
</PropertyGroup>
<!-- If the referenced projects have already been built, then just get the target paths -->
<MSBuild
Projects="@(_AppExtensionReferenceWithConfigurationExistent)"
Targets="GetBundleTargetPath"
Properties="%(_AppExtensionReferenceWithConfigurationExistent.SetConfiguration); %(_AppExtensionReferenceWithConfigurationExistent.SetPlatform)"
Condition="'@(_AppExtensionReferenceWithConfigurationExistent)' != '' and '$(_BuildReferencedExtensionProjects)' != 'true'">
<Output TaskParameter="TargetOutputs" ItemName="_ResolvedAppExtensionReferences" Condition="'%(_AppExtensionReferenceWithConfigurationExistent.ReferenceOutputAssembly)' != 'false'"/>
</MSBuild>
<!-- Build the referenced project if required -->
<MSBuild
Projects="@(_AppExtensionReferenceWithConfigurationExistent)"
Properties="%(_AppExtensionReferenceWithConfigurationExistent.SetConfiguration); %(_AppExtensionReferenceWithConfigurationExistent.SetPlatform)"
Condition="'@(_AppExtensionReferenceWithConfigurationExistent)' != '' and '$(_BuildReferencedExtensionProjects)' == 'true' ">
<Output TaskParameter="TargetOutputs" ItemName="_ResolvedAppExtensionReferences" Condition="'%(_AppExtensionReferenceWithConfigurationExistent.ReferenceOutputAssembly)' != 'false'"/>
</MSBuild>
<Warning Text="Referenced $(_PlatformName) App Extension Project %(_AppExtensionReferenceWithConfigurationNonExistent.Identity) not found, ignoring."
Condition="'@(_AppExtensionReferenceWithConfigurationNonExistent)' != ''"/>
</Target>
<Target Name="_PlaceAppExtensions" DependsOnTargets="_ExtendAppExtensionReferences;_ResolveAppExtensionReferences">
<ItemGroup>
<!-- Add a 'ContainerName' metadata to indicate where the extension should go inside the container's app bundle -->
<_ResolvedAppExtensionReferences Condition="'%(_ResolvedAppExtensionReferences.Extension)' == '.appex'">
<ContainerName>PlugIns</ContainerName>
</_ResolvedAppExtensionReferences>
<_ResolvedAppExtensionReferences Condition="'%(_ResolvedAppExtensionReferences.Extension)' == '.xpc'">
<ContainerName>XPCServices</ContainerName>
</_ResolvedAppExtensionReferences>
</ItemGroup>
<PropertyGroup>
<_AppExtensionRoot Condition="'$(_PlatformName)' == 'macOS'">$(_AppBundlePath)Contents\</_AppExtensionRoot>
<_AppExtensionRoot Condition="'$(_PlatformName)' != 'macOS'">$(_AppBundlePath)</_AppExtensionRoot>
</PropertyGroup>
</Target>
<Target Name="_CopyAppExtensionsToBundle"
DependsOnTargets="_ExtendAppExtensionReferences;_ResolveAppExtensionReferences;_PlaceAppExtensions"
Inputs="@(_ResolvedAppExtensionReferences)"
Outputs="$(_AppExtensionRoot)%(_ResolvedAppExtensionReferences.ContainerName)\%(_ResolvedAppExtensionReferences.FileName)%(_ResolvedAppExtensionReferences.Extension)"
>
<MakeDir
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
Directories="$(_AppExtensionRoot)%(_ResolvedAppExtensionReferences.ContainerName)"
/>
<Ditto
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
ToolExe="$(DittoExe)"
ToolPath="$(DittoPath)"
Source="@(_ResolvedAppExtensionReferences)"
Destination="$(_AppExtensionRoot)%(_ResolvedAppExtensionReferences.ContainerName)\%(_ResolvedAppExtensionReferences.FileName)%(_ResolvedAppExtensionReferences.Extension)"
/>
<!-- Delete any code signatures and dSYM dirs since they are now invalid -->
<RemoveDir
SessionId="$(BuildSessionId)"
Condition="'$(IsMacEnabled)' == 'true'"
Directories="$(_AppExtensionRoot)%(_ResolvedAppExtensionReferences.ContainerName)\%(_ResolvedAppExtensionReferences.FileName)%(_ResolvedAppExtensionReferences.Extension)\_CodeSignature;
$(_AppBundlePath)..\%(_ResolvedAppExtensionReferences.FileName)%(_ResolvedAppExtensionReferences.Extension).dSYM"
/>
</Target>
[msbuild] Add a Xamarin.Shared.ObjCBinding.targets file for shared binding code between Xamarin.iOS and Xamarin.Mac. (#9437) Add a Xamarin.Shared.ObjCBinding.targets file for shared binding code between Xamarin.iOS and Xamarin.Mac and start sharing some of the binding code.
2020-08-21 15:55:00 +03:00
<Import Project="$(MSBuildThisFileDirectory)Xamarin.Shared.ObjCBinding.targets" Condition="'$(IsBindingProject)' == 'true'" />
[msbuild] Share the logic to implicitly include netstandard.dll in the build. (#9146) In addition to the obvious benefit of reducing code duplication, this also means that implicit inclusion of netstandard.dll works for binding projects as well. The existing implementations were slightly different between Xamarin.iOS and Xamarin.Mac, so I tried to figure out the best merging strategy based on git history and looking at the original implementation of this code in MSBuild. I tried to keep close to the original implementation whenever I couldn't find a good reason to do otherwise.
2020-07-22 15:57:35 +03:00
<!-- Xamarin.ImplicitFacade.targets will detect if we need to add an implicit reference to netstandard.dll -->
<Import Project="$(MSBuildThisFileDirectory)Xamarin.ImplicitFacade.targets" Condition="!('$(_PlatformName)' == 'macOS' And '$(TargetFrameworkName)' == 'System')"/>
[msbuild] Share three stub targets for Windows between Xamarin.iOS and Xamarin.Mac. (#9443) These only apply to Xamarin.iOS right now, since they're Windows-specific (and we don't support Xamarin.Mac binding projects on Windows), but if we ever do end up supporting binding projects for Xamarin.Mac on Windows, we'll need these targets there, so just make them shared code.
2020-08-21 19:10:32 +03:00
<Import Project="$(MSBuildThisFileDirectory)Xamarin.Shared.Stubs.targets" />
Add 'NoBindingEmbedding' style binding project support (#5167) - Existing binding projects embed the native libraries within the assembly as managed resource - This does not scale well and has performance implications - This PR creates a new property, NoBindingEmbedding which when true processes the building and consumption of binding projects differently. - Existing binding projects are not affected, they will continue as is - I've written a full XM test suite and ported a subset to iOS. Since iOS only supports checked in projects, and I didn't want to make the existing situation worse by adding more, I only wrote tests that could use the existing test projects. -When we complete some form of msbuild testing reform, we'll revisit these tests. - Remove two files in MyiOSFrameworkBinding that are not used (we use copies elsewhere) - Remove unnecessary sleep and fix broken touch command - Output failing test log to console instead of test output - VSfM does not handle thousands of lines of test failure message well - Add ability to generate binding projects with LinkWith
2018-12-12 17:55:57 +03:00
<Import Project="$(MSBuildThisFileDirectory)$(MSBuildThisFileName).After.targets"
Condition="Exists('$(MSBuildThisFileDirectory)$(MSBuildThisFileName).After.targets')"/>
</Project>