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 }