private static void PrebuildProjectSettingUpdate()
{
appVersion = PlayerSettings.bundleVersion;
targetArchitecture = PlayerSettings.Android.targetArchitectures;
scriptBackend = PlayerSettings.GetScriptingBackend(EditorUserBuildSettings.selectedBuildTargetGroup);
managedStrippingLevel = PlayerSettings.GetManagedStrippingLevel(BuildTargetGroup.Android);
stripEngineCode = PlayerSettings.stripEngineCode;
PlayerSettings.bundleVersion = SQP_APK_VERSION;
if (targetArchitecture != AndroidArchitecture.ARMv7)
{
PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARMv7;
}
if (scriptBackend != ScriptingImplementation.Mono2x)
{
PlayerSettings.SetScriptingBackend(EditorUserBuildSettings.selectedBuildTargetGroup, ScriptingImplementation.Mono2x);
}
if (managedStrippingLevel != ManagedStrippingLevel.Disabled)
{
PlayerSettings.SetManagedStrippingLevel(BuildTargetGroup.Android, ManagedStrippingLevel.Disabled);
}
if (stripEngineCode)
{
PlayerSettings.stripEngineCode = false;
}
}
//Backup Player Settings of original project and change the to loader APK settings before building loader APK
private static void BackupAndChangePlayerSettings()
{
originalCompanyName = PlayerSettings.companyName;
originalProductName = PlayerSettings.productName;
originalPackageName = PlayerSettings.applicationIdentifier;
originalVersion = PlayerSettings.bundleVersion;
originalBundleVersionCode = PlayerSettings.Android.bundleVersionCode;
originalScriptingBackEnd = PlayerSettings.GetScriptingBackend(BuildTargetGroup.Android);
PlayerSettings.companyName = loaderCompanyName;
PlayerSettings.productName = loaderProductName;
PlayerSettings.applicationIdentifier = loaderPackageName;
PlayerSettings.bundleVersion = loaderVersion;
PlayerSettings.Android.bundleVersionCode = loaderBundleVersionCode;
PlayerSettings.SetScriptingBackend(BuildTargetGroup.Android, loaderScriptingBackEnd);
#if UNITY_2018_3_OR_NEWER
originalManagedStrippingLevel = PlayerSettings.GetManagedStrippingLevel(BuildTargetGroup.Android);
PlayerSettings.SetManagedStrippingLevel(BuildTargetGroup.Android, loaderManagedStrippingLevel);
#else
originalStrippingLevel = PlayerSettings.strippingLevel;
PlayerSettings.strippingLevel = loaderStrippingLevel;
#endif
originalStripEngineCode = PlayerSettings.stripEngineCode;
PlayerSettings.stripEngineCode = loaderStripEngineCode;
}
static SetAndroid()
{
if (!PlayerSettings.Android.forceInternetPermission)
{
PlayerSettings.Android.forceInternetPermission = true;
Debug.Log("Android: 'forceInternetPermission' set to true");
}
BuildTarget target = EditorUserBuildSettings.activeBuildTarget;
BuildTargetGroup group = BuildPipeline.GetBuildTargetGroup(target);
#if UNITY_2018_3_OR_NEWER
ManagedStrippingLevel level = ManagedStrippingLevel.Disabled;
if (PlayerSettings.GetScriptingBackend(group) == ScriptingImplementation.Mono2x && PlayerSettings.GetManagedStrippingLevel(group) != level)
{
PlayerSettings.SetManagedStrippingLevel(group, level);
Debug.Log("Android: stripping level changed to '" + level + "'");
}
#else
StrippingLevel level = StrippingLevel.Disabled;
if (PlayerSettings.GetScriptingBackend(group) == ScriptingImplementation.Mono2x && PlayerSettings.strippingLevel != level)
{
PlayerSettings.strippingLevel = level;
Debug.Log("Android: stripping level changed to '" + level + "'");
}
#endif
}
private static void PrebuildProjectSettingUpdate()
{
// Modify application identifier for transition APK
projectDefaultAppIdentifier = PlayerSettings.GetApplicationIdentifier(BuildTargetGroup.Android);
PlayerSettings.SetApplicationIdentifier(BuildTargetGroup.Android,
projectDefaultAppIdentifier + GetTransitionApkOptionalIdentifier());
// Set VersionCode as a unique identifier for transition APK
projectDefaultVersion = PlayerSettings.bundleVersion;
PlayerSettings.bundleVersion = TRANSITION_APK_VERSION_NAME;
// Modify IL2CPP option as it strips script symbols that are necessary for the scenes at runtime
projectScriptImplementation = PlayerSettings.GetScriptingBackend(EditorUserBuildSettings.selectedBuildTargetGroup);
if (projectScriptImplementation != ScriptingImplementation.Mono2x)
{
// Show message in console to make it more clear to developers
OVRBundleTool.PrintLog("Build will use Mono as scripting backend.");
PlayerSettings.SetScriptingBackend(EditorUserBuildSettings.selectedBuildTargetGroup, ScriptingImplementation.Mono2x);
}
// Avoid stripping managed code that are necessary for the scenes at runtime
projectManagedStrippingLevel = PlayerSettings.GetManagedStrippingLevel(BuildTargetGroup.Android);
if (projectManagedStrippingLevel != ManagedStrippingLevel.Disabled)
{
OVRBundleTool.PrintLog("Build will set Managed Stripping Level to Disabled.");
PlayerSettings.SetManagedStrippingLevel(BuildTargetGroup.Android, ManagedStrippingLevel.Disabled);
}
projectStripEngineCode = PlayerSettings.stripEngineCode;
if (projectStripEngineCode)
{
PlayerSettings.stripEngineCode = false;
}
}
internal static void StripAssemblies(string managedAssemblyFolderPath, BaseUnityLinkerPlatformProvider unityLinkerPlatformProvider, IIl2CppPlatformProvider il2cppPlatformProvider,
RuntimeClassRegistry rcr, ManagedStrippingLevel managedStrippingLevel)
{
var runInformation = new UnityLinkerRunInformation(managedAssemblyFolderPath, unityLinkerPlatformProvider, il2cppPlatformProvider.target, rcr, managedStrippingLevel, il2cppPlatformProvider);
RunAssemblyStripper(runInformation);
}
public void Initialize(BuildConfiguration.ReadOnly config)
{
var group = config.GetBuildTargetGroup();
if (group == BuildTargetGroup.Unknown)
{
return;
}
StripEngineCode = PlayerSettings.stripEngineCode;
ManagedStrippingLevel = PlayerSettings.GetManagedStrippingLevel(group);
}
void ICustomBuildComponentConstructor.Construct(BuildConfiguration.ReadOnly config)
{
var group = config.GetBuildTargetGroup();
if (group == BuildTargetGroup.Unknown)
{
return;
}
StripEngineCode = PlayerSettings.stripEngineCode;
ManagedStrippingLevel = PlayerSettings.GetManagedStrippingLevel(group);
}
private static string GetRuleSetForStrippingLevel(ManagedStrippingLevel managedStrippingLevel)
{
switch (managedStrippingLevel)
{
case ManagedStrippingLevel.Low:
return("Conservative");
case ManagedStrippingLevel.Medium:
return("Aggressive");
case ManagedStrippingLevel.High:
return("Experimental");
}
throw new ArgumentException($"Unhandled {nameof(ManagedStrippingLevel)} value of {managedStrippingLevel}");
}
public static void PrebuildProjectSettingUpdate()
{
// Save existing settings as some modifications can change other settings
projectDefaultAppIdentifier = PlayerSettings.GetApplicationIdentifier(BuildTargetGroup.Android);
projectDefaultVersion = PlayerSettings.bundleVersion;
projectAndroidArchitecture = PlayerSettings.Android.targetArchitectures;
projectScriptImplementation = PlayerSettings.GetScriptingBackend(EditorUserBuildSettings.selectedBuildTargetGroup);
projectManagedStrippingLevel = PlayerSettings.GetManagedStrippingLevel(BuildTargetGroup.Android);
projectStripEngineCode = PlayerSettings.stripEngineCode;
// Modify application identifier for transition APK
PlayerSettings.SetApplicationIdentifier(BuildTargetGroup.Android,
projectDefaultAppIdentifier + GetTransitionApkOptionalIdentifier());
// Set VersionCode as a unique identifier for transition APK
PlayerSettings.bundleVersion = TRANSITION_APK_VERSION_NAME;
// Modify Android target architecture as ARM64 does not support Mono.
if (projectAndroidArchitecture != AndroidArchitecture.ARMv7)
{
// Show message in console to make it more clear to developers
OVRBundleTool.PrintLog("Build will use ARMv7 as Android architecture.");
PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARMv7;
}
// Modify IL2CPP option as it strips script symbols that are necessary for the scenes at runtime
if (projectScriptImplementation != ScriptingImplementation.Mono2x)
{
// Show message in console to make it more clear to developers
OVRBundleTool.PrintLog("Build will use Mono as scripting backend.");
PlayerSettings.SetScriptingBackend(EditorUserBuildSettings.selectedBuildTargetGroup, ScriptingImplementation.Mono2x);
}
// Avoid stripping managed code that are necessary for the scenes at runtime
if (projectManagedStrippingLevel != ManagedStrippingLevel.Disabled)
{
OVRBundleTool.PrintLog("Build will set Managed Stripping Level to Disabled.");
PlayerSettings.SetManagedStrippingLevel(BuildTargetGroup.Android, ManagedStrippingLevel.Disabled);
}
if (projectStripEngineCode)
{
OVRBundleTool.PrintLog("Build will set Strip Engine Code to Disabled.");
PlayerSettings.stripEngineCode = false;
}
}
public UnityLinkerRunInformation(string managedAssemblyFolderPath,
BaseUnityLinkerPlatformProvider platformProvider, BuildTarget buildTarget,
RuntimeClassRegistry rcr, ManagedStrippingLevel managedStrippingLevel,
IIl2CppPlatformProvider il2CppPlatformProvider)
{
this.managedAssemblyFolderPath = managedAssemblyFolderPath;
target = buildTarget;
this.platformProvider = platformProvider;
this.rcr = rcr;
this.managedStrippingLevel = managedStrippingLevel;
this.il2CppPlatformProvider = il2CppPlatformProvider;
pipelineData = new UnityLinkerBuildPipelineData(target, managedAssemblyFolderPath);
buildTargetGroup = BuildPipeline.GetBuildTargetGroup(buildTarget);
argumentProvider = new UnityLinkerArgumentValueProvider(this);
isMonoBackend = PlayerSettings.GetScriptingBackend(buildTargetGroup) == ScriptingImplementation.Mono2x;
engineStrippingSupported = platformProvider.supportsEngineStripping && !isMonoBackend;
performEngineStripping = rcr != null && PlayerSettings.stripEngineCode && engineStrippingSupported;
}
public void takeSnapshot(BuildTargetGroup targetGroup)
{
buildTargetGroup = targetGroup;
scriptingBackend = PlayerSettings.GetScriptingBackend(targetGroup);
scriptingDefineSymbols = PlayerSettings.GetScriptingDefineSymbolsForGroup(targetGroup);
#if UNITY_2018_3_OR_NEWER
strippingLevel = PlayerSettings.GetManagedStrippingLevel(targetGroup);
#endif
#if UNITY_2017_2_OR_NEWER
vrSupported = PlayerSettings.GetVirtualRealitySupported(targetGroup);
#endif
vrSdks = VRUtils.getAvailableVRSdks(targetGroup);
#if UNITY_2017_4_OR_NEWER
androidAppBundleEnabled = EditorUserBuildSettings.buildAppBundle;
#endif
}
public static extern void SetManagedStrippingLevel(BuildTargetGroup targetGroup, ManagedStrippingLevel level);
public static void StripAssembliesWrap(string managedAssemblyFolderPath, object platformProvider, object rcr, ManagedStrippingLevel managedStrippingLevel)
#endif
{
throw new NotImplementedException();
}
private static bool StripAssembliesTo(string[] assemblies, string[] searchDirs, string outputFolder, string workingDirectory, out string output, out string error, string linkerPath, IIl2CppPlatformProvider platformProvider, IEnumerable <string> additionalBlacklist, BuildTargetGroup buildTargetGroup, ManagedStrippingLevel managedStrippingLevel)
{
if (!Directory.Exists(outputFolder))
{
Directory.CreateDirectory(outputFolder);
}
additionalBlacklist = additionalBlacklist.Select(s => Path.IsPathRooted(s) ? s : Path.Combine(workingDirectory, s)).Where(File.Exists);
var userBlackLists = GetUserBlacklistFiles();
foreach (var ub in userBlackLists)
{
Console.WriteLine("UserBlackList: " + ub);
}
additionalBlacklist = additionalBlacklist.Concat(userBlackLists);
var args = new List <string>
{
"-out=\"" + outputFolder + "\"",
"-x=\"" + GetModuleWhitelist("Core", platformProvider.moduleStrippingInformationFolder) + "\"",
};
args.AddRange(additionalBlacklist.Select(path => "-x \"" + path + "\""));
args.AddRange(searchDirs.Select(d => "-d \"" + d + "\""));
args.AddRange(assemblies.Select(assembly => "--include-unity-root-assembly=\"" + Path.GetFullPath(assembly) + "\""));
args.Add($"--dotnetruntime={GetRuntimeArgumentValueForLinker(buildTargetGroup)}");
args.Add($"--dotnetprofile={GetProfileArgumentValueForLinker(buildTargetGroup)}");
args.Add("--use-editor-options");
args.Add($"--include-directory={CommandLineFormatter.PrepareFileName(workingDirectory)}");
if (EditorUserBuildSettings.allowDebugging)
{
args.Add("--editor-settings-flag=AllowDebugging");
}
if (EditorUserBuildSettings.development)
{
args.Add("--editor-settings-flag=Development");
}
args.Add($"--rule-set={GetRuleSetForStrippingLevel(managedStrippingLevel)}");
// One final check to make sure we only run high on latest runtime.
if ((managedStrippingLevel == ManagedStrippingLevel.High) && (PlayerSettingsEditor.IsLatestApiCompatibility(PlayerSettings.GetApiCompatibilityLevel(buildTargetGroup))))
{
// Prepare the arguments to run the UnityLinker. When in high mode, need to also
// supply the IL2CPP compiler platform and compiler architecture. When the scripting backend
// is not IL2CPP, we have to map those strings and use a utility function to figure out proper strings.
// Currently only need to do this on the non aot platforms of Android, Windows, Mac, Linux.
var compilerPlatform = "";
var compilerArchitecture = "";
Il2CppNativeCodeBuilder il2cppNativeCodeBuilder = platformProvider.CreateIl2CppNativeCodeBuilder();
if (il2cppNativeCodeBuilder != null)
{
compilerPlatform = il2cppNativeCodeBuilder.CompilerPlatform;
compilerArchitecture = il2cppNativeCodeBuilder.CompilerArchitecture;
}
else
{
GetUnityLinkerPlatformStringsFromBuildTarget(platformProvider.target, out compilerPlatform, out compilerArchitecture);
}
args.Add($"--platform={compilerPlatform}");
if (platformProvider.target != BuildTarget.Android)
{
args.Add($"--architecture={compilerArchitecture}");
}
}
var additionalArgs = System.Environment.GetEnvironmentVariable("UNITYLINKER_ADDITIONAL_ARGS");
if (!string.IsNullOrEmpty(additionalArgs))
{
args.Add(additionalArgs);
}
additionalArgs = Debug.GetDiagnosticSwitch("VMUnityLinkerAdditionalArgs") as string;
if (!string.IsNullOrEmpty(additionalArgs))
{
args.Add(additionalArgs.Trim('\''));
}
return(RunAssemblyLinker(args, out output, out error, linkerPath, workingDirectory));
}
static public void InvokeFromBuildPlayer(BuildTarget buildTarget, RuntimeClassRegistry usedClasses, ManagedStrippingLevel managedStrippingLevel, BuildReport report)
{
var stagingAreaData = Paths.Combine("Temp", "StagingArea", "Data");
var platformProvider = new BaseIl2CppPlatformProvider(buildTarget, Path.Combine(stagingAreaData, "Libraries"), report);
var managedAssemblyFolderPath = Path.GetFullPath(Path.Combine(stagingAreaData, "Managed"));
AssemblyStripper.StripAssemblies(managedAssemblyFolderPath, platformProvider, usedClasses, managedStrippingLevel);
}
private static void RunAssemblyStripper(IEnumerable assemblies, string managedAssemblyFolderPath, string[] assembliesToStrip, string[] searchDirs, string monoLinkerPath, IIl2CppPlatformProvider platformProvider, RuntimeClassRegistry rcr, ManagedStrippingLevel managedStrippingLevel)
{
string output;
string error;
var buildTargetGroup = BuildPipeline.GetBuildTargetGroup(platformProvider.target);
bool isMono = PlayerSettings.GetScriptingBackend(buildTargetGroup) == ScriptingImplementation.Mono2x;
bool stripEngineCode = rcr != null && PlayerSettings.stripEngineCode && platformProvider.supportsEngineStripping && !EditorUserBuildSettings.buildScriptsOnly;
IEnumerable <string> blacklists = Il2CppBlacklistPaths;
if (rcr != null)
{
blacklists = blacklists.Concat(new[]
{
WriteMethodsToPreserveBlackList(rcr, platformProvider.target),
MonoAssemblyStripping.GenerateLinkXmlToPreserveDerivedTypes(managedAssemblyFolderPath, rcr)
});
}
if (isMono)
{
// The old Mono assembly stripper uses per-platform link.xml files if available. Apply these here.
var buildToolsDirectory = BuildPipeline.GetBuildToolsDirectory(platformProvider.target);
if (!string.IsNullOrEmpty(buildToolsDirectory))
{
var platformDescriptor = Path.Combine(buildToolsDirectory, "link.xml");
if (File.Exists(platformDescriptor))
{
blacklists = blacklists.Concat(new[] { platformDescriptor });
}
}
}
if (!stripEngineCode)
{
// if we don't do stripping, add all modules blacklists.
foreach (var file in Directory.GetFiles(platformProvider.moduleStrippingInformationFolder, "*.xml"))
{
blacklists = blacklists.Concat(new[] { file });
}
}
// Generated link xml files that would have been empty will be nulled out. Need to filter these out before running the linker
blacklists = blacklists.Where(b => b != null);
var tempStripPath = Path.GetFullPath(Path.Combine(managedAssemblyFolderPath, "tempStrip"));
bool addedMoreBlacklists;
do
{
addedMoreBlacklists = false;
if (EditorUtility.DisplayCancelableProgressBar("Building Player", "Stripping assemblies", 0.0f))
{
throw new OperationCanceledException();
}
if (!StripAssembliesTo(
assembliesToStrip,
searchDirs,
tempStripPath,
managedAssemblyFolderPath,
out output,
out error,
monoLinkerPath,
platformProvider,
blacklists,
buildTargetGroup,
managedStrippingLevel))
{
throw new Exception("Error in stripping assemblies: " + assemblies + ", " + error);
}
if (platformProvider.supportsEngineStripping)
{
var icallSummaryPath = Path.Combine(managedAssemblyFolderPath, "ICallSummary.txt");
GenerateInternalCallSummaryFile(icallSummaryPath, managedAssemblyFolderPath, tempStripPath);
if (stripEngineCode)
{
// Find which modules we must include in the build based on Assemblies
HashSet <UnityType> nativeClasses;
HashSet <string> nativeModules;
CodeStrippingUtils.GenerateDependencies(tempStripPath, icallSummaryPath, rcr, stripEngineCode, out nativeClasses, out nativeModules, platformProvider);
// Add module-specific blacklists.
addedMoreBlacklists = AddWhiteListsForModules(nativeModules, ref blacklists, platformProvider.moduleStrippingInformationFolder);
}
}
// If we had to add more whitelists, we need to run AssemblyStripper again with the added whitelists.
}while (addedMoreBlacklists);
// keep unstripped files for debugging purposes
var tempUnstrippedPath = Path.GetFullPath(Path.Combine(managedAssemblyFolderPath, "tempUnstripped"));
if (debugUnstripped)
{
Directory.CreateDirectory(tempUnstrippedPath);
}
foreach (var file in Directory.GetFiles(managedAssemblyFolderPath))
{
var extension = Path.GetExtension(file);
if (string.Equals(extension, ".dll", StringComparison.InvariantCultureIgnoreCase) ||
string.Equals(extension, ".winmd", StringComparison.InvariantCultureIgnoreCase) ||
string.Equals(extension, ".mdb", StringComparison.InvariantCultureIgnoreCase) ||
string.Equals(extension, ".pdb", StringComparison.InvariantCultureIgnoreCase))
{
if (debugUnstripped)
{
File.Move(file, Path.Combine(tempUnstrippedPath, Path.GetFileName(file)));
}
else
{
File.Delete(file);
}
}
}
foreach (var file in Directory.GetFiles(tempStripPath))
{
File.Move(file, Path.Combine(managedAssemblyFolderPath, Path.GetFileName(file)));
}
foreach (var dir in Directory.GetDirectories(tempStripPath))
{
Directory.Move(dir, Path.Combine(managedAssemblyFolderPath, Path.GetFileName(dir)));
}
Directory.Delete(tempStripPath);
}
internal static void StripAssemblies(string managedAssemblyFolderPath, IIl2CppPlatformProvider platformProvider, RuntimeClassRegistry rcr, ManagedStrippingLevel managedStrippingLevel)
{
var assemblies = GetUserAssemblies(rcr, managedAssemblyFolderPath);
assemblies.AddRange(Directory.GetFiles(managedAssemblyFolderPath, "I18N*.dll", SearchOption.TopDirectoryOnly));
var assembliesToStrip = assemblies.ToArray();
var searchDirs = new[]
{
managedAssemblyFolderPath
};
RunAssemblyStripper(assemblies, managedAssemblyFolderPath, assembliesToStrip, searchDirs, UnityLinkerPath, platformProvider, rcr, managedStrippingLevel);
}
private static bool StripAssembliesTo(string[] assemblies, string[] searchDirs, string outputFolder, string workingDirectory, out string output, out string error, string linkerPath, IIl2CppPlatformProvider platformProvider, IEnumerable <string> additionalBlacklist, BuildTargetGroup buildTargetGroup, ManagedStrippingLevel managedStrippingLevel, bool stripEngineCode, string editorToLinkerDataPath)
{
if (!Directory.Exists(outputFolder))
{
Directory.CreateDirectory(outputFolder);
}
additionalBlacklist = additionalBlacklist.Select(s => Path.IsPathRooted(s) ? s : Path.Combine(workingDirectory, s)).Where(File.Exists);
var userBlackLists = GetUserBlacklistFiles();
foreach (var ub in userBlackLists)
{
Console.WriteLine("UserBlackList: " + ub);
}
additionalBlacklist = additionalBlacklist.Concat(userBlackLists);
var args = new List <string>
{
$"-out={CommandLineFormatter.PrepareFileName(outputFolder)}",
};
if (!UseUnityLinkerEngineModuleStripping)
{
args.Add($"-x={CommandLineFormatter.PrepareFileName(GetModuleWhitelist("Core", platformProvider.moduleStrippingInformationFolder))}");
}
args.AddRange(additionalBlacklist.Select(path => $"-x={CommandLineFormatter.PrepareFileName(path)}"));
args.AddRange(searchDirs.Select(d => $"-d={CommandLineFormatter.PrepareFileName(d)}"));
args.AddRange(assemblies.Select(assembly => $"--include-unity-root-assembly={CommandLineFormatter.PrepareFileName(Path.GetFullPath(assembly))}"));
args.Add($"--dotnetruntime={GetRuntimeArgumentValueForLinker(buildTargetGroup)}");
args.Add($"--dotnetprofile={GetProfileArgumentValueForLinker(buildTargetGroup)}");
args.Add("--use-editor-options");
args.Add($"--include-directory={CommandLineFormatter.PrepareFileName(workingDirectory)}");
if (EditorUserBuildSettings.allowDebugging)
{
args.Add("--editor-settings-flag=AllowDebugging");
}
if (EditorUserBuildSettings.development)
{
args.Add("--editor-settings-flag=Development");
}
args.Add($"--rule-set={GetRuleSetForStrippingLevel(managedStrippingLevel)}");
args.Add($"--editor-data-file={CommandLineFormatter.PrepareFileName(editorToLinkerDataPath)}");
var compilerPlatform = "";
var compilerArchitecture = "";
Il2CppNativeCodeBuilder il2cppNativeCodeBuilder = platformProvider.CreateIl2CppNativeCodeBuilder();
if (il2cppNativeCodeBuilder != null)
{
compilerPlatform = il2cppNativeCodeBuilder.CompilerPlatform;
compilerArchitecture = il2cppNativeCodeBuilder.CompilerArchitecture;
}
else
{
// When the scripting backend is not IL2CPP, we have to map those strings and use a utility function to figure out proper strings.
GetUnityLinkerPlatformStringsFromBuildTarget(platformProvider.target, out compilerPlatform, out compilerArchitecture);
}
args.Add($"--platform={compilerPlatform}");
if (!string.IsNullOrEmpty(compilerArchitecture))
{
args.Add($"--architecture={compilerArchitecture}");
}
if (!UseUnityLinkerEngineModuleStripping)
{
args.Add("--disable-engine-module-support");
}
if (stripEngineCode)
{
args.Add("--enable-engine-module-stripping");
if (UnityEngine.Connect.UnityConnectSettings.enabled)
{
args.Add("--engine-stripping-flag=EnableUnityConnect");
}
if (UnityEngine.Analytics.PerformanceReporting.enabled)
{
args.Add("--engine-stripping-flag=EnablePerformanceReporting");
}
if (UnityEngine.Analytics.Analytics.enabled)
{
args.Add("--engine-stripping-flag=EnableAnalytics");
}
if (UnityEditor.CrashReporting.CrashReportingSettings.enabled)
{
args.Add("--engine-stripping-flag=EnableCrashReporting");
}
if (UnityEditorInternal.VR.VRModule.ShouldInjectVRDependenciesForBuildTarget(platformProvider.target))
{
args.Add("--engine-stripping-flag=EnableVR");
}
}
var modulesAssetPath = Path.Combine(platformProvider.moduleStrippingInformationFolder, "../modules.asset");
if (File.Exists(modulesAssetPath))
{
args.Add($"--engine-modules-asset-file={CommandLineFormatter.PrepareFileName(modulesAssetPath)}");
}
var additionalArgs = System.Environment.GetEnvironmentVariable("UNITYLINKER_ADDITIONAL_ARGS");
if (!string.IsNullOrEmpty(additionalArgs))
{
args.Add(additionalArgs);
}
additionalArgs = Debug.GetDiagnosticSwitch("VMUnityLinkerAdditionalArgs") as string;
if (!string.IsNullOrEmpty(additionalArgs))
{
args.Add(additionalArgs.Trim('\''));
}
return(RunAssemblyLinker(args, out output, out error, linkerPath, workingDirectory));
}
//redirect to AssemblyStripper.StripAssemblies
#if UNITY_2019_1_OR_NEWER
public static void StripAssembliesWrap(string managedAssemblyFolderPath, object unityLinkerPlatformProvider, object il2cppPlatformProvider, object rcr, ManagedStrippingLevel managedStrippingLevel)
internal static void SetManagedStrippingLevel(BuildTargetGroup targetGroup, ManagedStrippingLevel strippingLevel = ManagedStrippingLevel.Disabled)
{
PlayerSettings.SetManagedStrippingLevel(targetGroup, strippingLevel);
}
static public void StripForMonoBackend(BuildTarget buildTarget, RuntimeClassRegistry usedClasses, ManagedStrippingLevel managedStrippingLevel, BuildReport report)
{
if (managedStrippingLevel == ManagedStrippingLevel.Disabled)
{
return;
}
var stagingAreaData = Paths.Combine("Temp", "StagingArea", "Data");
var il2cppPlatformProvider = new MonoBackendIl2CppPlatformProvider(buildTarget, Path.Combine(stagingAreaData, "Libraries"), report);
var platformProvider = new MonoBackendUnityLinkerPlatformProvider(buildTarget);
var managedAssemblyFolderPath = Path.GetFullPath(Path.Combine(stagingAreaData, "Managed"));
AssemblyStripper.StripAssemblies(managedAssemblyFolderPath, platformProvider, il2cppPlatformProvider, usedClasses, managedStrippingLevel);
}
public static void StripAssemblies(string managedAssemblyFolderPath, object platformProvider, object rcr, ManagedStrippingLevel managedStrippingLevel)
#endif
{
if (stripHooker != null)
{
stripHooker.Dispose();
stripHooker = null;
}
RunBinderBeforeStrip(managedAssemblyFolderPath);
// call the realy method
#if UNITY_2019_1_OR_NEWER
StripAssembliesWrap(managedAssemblyFolderPath, unityLinkerPlatformProvider, il2cppPlatformProvider, rcr, managedStrippingLevel);
#else
StripAssembliesWrap(managedAssemblyFolderPath, platformProvider, rcr, managedStrippingLevel);
#endif
}
