| private GetPlaybackEngineDirectory ( BuildTarget target, BuildOptions options ) : string | ||
| target | BuildTarget | |
| options | BuildOptions | |
| return | string | |
public static void Postprocess(BuildTargetGroup targetGroup, BuildTarget target, string installPath, string companyName, string productName, int width, int height, BuildOptions options, RuntimeClassRegistry usedClassRegistry, BuildReport report)
{
string stagingArea = "Temp/StagingArea";
string stagingAreaData = "Temp/StagingArea/Data";
string stagingAreaDataManaged = "Temp/StagingArea/Data/Managed";
string playbackEngineDirectory = BuildPipeline.GetPlaybackEngineDirectory(target, options);
bool flag = (options & BuildOptions.InstallInBuildFolder) != BuildOptions.None && PostprocessBuildPlayer.SupportsInstallInBuildFolder(targetGroup, target);
if (installPath == string.Empty && !flag)
{
throw new Exception(installPath + " must not be an empty string");
}
IBuildPostprocessor buildPostProcessor = ModuleManager.GetBuildPostProcessor(targetGroup, target);
if (buildPostProcessor != null)
{
BuildPostProcessArgs args;
args.target = target;
args.stagingAreaData = stagingAreaData;
args.stagingArea = stagingArea;
args.stagingAreaDataManaged = stagingAreaDataManaged;
args.playerPackage = playbackEngineDirectory;
args.installPath = installPath;
args.companyName = companyName;
args.productName = productName;
args.productGUID = PlayerSettings.productGUID;
args.options = options;
args.usedClassRegistry = usedClassRegistry;
args.report = report;
buildPostProcessor.PostProcess(args);
return;
}
throw new UnityException(string.Format("Build target '{0}' not supported", target));
}
public static void Postprocess(BuildTarget target, string installPath, string companyName, string productName, int width, int height, string downloadWebplayerUrl, string manualDownloadWebplayerUrl, BuildOptions options, RuntimeClassRegistry usedClassRegistry, BuildReport report)
{
BuildPostProcessArgs args;
string str = "Temp/StagingArea";
string str2 = "Temp/StagingArea/Data";
string str3 = "Temp/StagingArea/Data/Managed";
string playbackEngineDirectory = BuildPipeline.GetPlaybackEngineDirectory(target, options);
bool flag = ((options & BuildOptions.InstallInBuildFolder) != BuildOptions.CompressTextures) && SupportsInstallInBuildFolder(target);
if ((installPath == string.Empty) && !flag)
{
throw new Exception(installPath + " must not be an empty string");
}
IBuildPostprocessor buildPostProcessor = ModuleManager.GetBuildPostProcessor(target);
if (buildPostProcessor == null)
{
throw new UnityException($"Build target '{target}' not supported");
}
args.target = target;
args.stagingAreaData = str2;
args.stagingArea = str;
args.stagingAreaDataManaged = str3;
args.playerPackage = playbackEngineDirectory;
args.installPath = installPath;
args.companyName = companyName;
args.productName = productName;
args.productGUID = PlayerSettings.productGUID;
args.options = options;
args.usedClassRegistry = usedClassRegistry;
args.report = report;
buildPostProcessor.PostProcess(args);
}
static public void Postprocess(BuildTargetGroup targetGroup, BuildTarget target, int subtarget, string installPath, string companyName, string productName,
int width, int height, BuildOptions options,
RuntimeClassRegistry usedClassRegistry, BuildReport report)
{
string stagingArea = "Temp/StagingArea";
string stagingAreaData = "Temp/StagingArea/Data";
string stagingAreaDataManaged = "Temp/StagingArea/Data/Managed";
string playerPackage = BuildPipeline.GetPlaybackEngineDirectory(target, options);
// Disallow providing an empty string as the installPath
bool willInstallInBuildFolder = (options & BuildOptions.InstallInBuildFolder) != 0 && SupportsInstallInBuildFolder(targetGroup, target);
if (installPath == String.Empty && !willInstallInBuildFolder)
{
throw new Exception(installPath + " must not be an empty string");
}
IBuildPostprocessor postprocessor = ModuleManager.GetBuildPostProcessor(targetGroup, target);
if (postprocessor != null)
{
BuildPostProcessArgs args;
args.target = target;
args.subtarget = subtarget;
args.stagingAreaData = stagingAreaData;
args.stagingArea = stagingArea;
args.stagingAreaDataManaged = stagingAreaDataManaged;
args.playerPackage = playerPackage;
args.installPath = installPath;
args.companyName = companyName;
args.productName = productName;
args.productGUID = PlayerSettings.productGUID;
args.options = options;
args.usedClassRegistry = usedClassRegistry;
args.report = report;
BuildProperties props;
try
{
postprocessor.PostProcess(args, out props);
}
catch (System.Exception e)
{
// Rethrow exceptions during build postprocessing as BuildFailedException, so we don't pretend the build was fine.
throw new UnityEditor.Build.BuildFailedException(e);
}
report.AddAppendix(props);
return;
}
// If postprocessor is not provided, build target is not supported
throw new UnityException(string.Format("Build target '{0}' not supported", target));
}
public static void Launch(BuildTarget target, string path, string productName, BuildOptions options)
{
BuildLaunchPlayerArgs args;
IBuildPostprocessor buildPostProcessor = ModuleManager.GetBuildPostProcessor(target);
if (buildPostProcessor == null)
{
throw new UnityException($"Launching {target} build target via mono is not supported");
}
args.target = target;
args.playerPackage = BuildPipeline.GetPlaybackEngineDirectory(target, options);
args.installPath = path;
args.productName = productName;
args.options = options;
buildPostProcessor.LaunchPlayer(args);
}
public static void Launch(BuildTargetGroup targetGroup, BuildTarget buildTarget, string path, string productName, BuildOptions options, BuildReport buildReport)
{
IBuildPostprocessor buildPostProcessor = ModuleManager.GetBuildPostProcessor(targetGroup, buildTarget);
if (buildPostProcessor != null)
{
BuildLaunchPlayerArgs args;
args.target = buildTarget;
args.playerPackage = BuildPipeline.GetPlaybackEngineDirectory(buildTarget, options);
args.installPath = path;
args.productName = productName;
args.options = options;
args.report = buildReport;
buildPostProcessor.LaunchPlayer(args);
return;
}
throw new UnityException(string.Format("Launching for target group {0}, build target {1} is not supported: There is no build post-processor available.", targetGroup, buildTarget));
}
public static void Postprocess(BuildTarget target, string installPath, string companyName, string productName, int width, int height, string downloadWebplayerUrl, string manualDownloadWebplayerUrl, BuildOptions options, RuntimeClassRegistry usedClassRegistry)
{
string str1 = "Temp/StagingArea";
string str2 = "Temp/StagingArea/Data";
string str3 = "Temp/StagingArea/Data/Managed";
string playbackEngineDirectory = BuildPipeline.GetPlaybackEngineDirectory(target, options);
bool flag = (options & BuildOptions.InstallInBuildFolder) != BuildOptions.None && PostprocessBuildPlayer.SupportsInstallInBuildFolder(target);
if (installPath == string.Empty && !flag)
{
throw new Exception(installPath + " must not be an empty string");
}
IBuildPostprocessor buildPostProcessor = ModuleManager.GetBuildPostProcessor(target);
if (buildPostProcessor != null)
{
BuildPostProcessArgs args;
args.target = target;
args.stagingAreaData = str2;
args.stagingArea = str1;
args.stagingAreaDataManaged = str3;
args.playerPackage = playbackEngineDirectory;
args.installPath = installPath;
args.companyName = companyName;
args.productName = productName;
args.productGUID = PlayerSettings.productGUID;
args.options = options;
args.usedClassRegistry = usedClassRegistry;
buildPostProcessor.PostProcess(args);
}
else
{
switch (target)
{
case BuildTarget.WebPlayer:
case BuildTarget.WebPlayerStreamed:
PostProcessWebPlayer.PostProcess(options, installPath, downloadWebplayerUrl, width, height);
break;
default:
throw new UnityException(string.Format("Build target '{0}' not supported", (object)target));
}
}
}
internal static string GetPlaybackEngineDirectory(BuildTarget target, BuildOptions options)
{
BuildTargetGroup buildTargetGroup = BuildPipeline.GetBuildTargetGroup(target);
return(BuildPipeline.GetPlaybackEngineDirectory(buildTargetGroup, target, options));
}
public static void Launch(BuildTargetGroup targetGroup, BuildTarget buildTarget, string path, string productName, BuildOptions options, BuildReport buildReport)
{
try
{
if (buildReport == null)
{
throw new NotSupportedException();
}
ProgressHandler handler = new ProgressHandler("Deploying Player", delegate(string title, string message, float globalProgress)
{
if (EditorUtility.DisplayCancelableProgressBar(title, message, globalProgress))
{
throw new OperationAbortedException();
}
}, 0.1f, 1f);
ProgressTaskManager taskManager = new ProgressTaskManager(handler);
List <DeploymentTargetId> validTargetIds = null;
taskManager.AddTask(delegate
{
taskManager.UpdateProgress("Finding valid devices for build");
validTargetIds = DeploymentTargetManager.FindValidTargetsForLaunchBuild(targetGroup, buildReport);
if (!validTargetIds.Any <DeploymentTargetId>())
{
throw new PostprocessBuildPlayer.NoTargetsFoundException("Could not find any valid targets for build");
}
});
taskManager.AddTask(delegate
{
foreach (DeploymentTargetId current in validTargetIds)
{
bool flag = current == validTargetIds[validTargetIds.Count - 1];
try
{
DeploymentTargetManager.LaunchBuildOnTarget(targetGroup, buildReport, current, taskManager.SpawnProgressHandlerFromCurrentTask());
return;
}
catch (OperationFailedException ex2)
{
UnityEngine.Debug.LogException(ex2);
if (flag)
{
throw ex2;
}
}
}
throw new PostprocessBuildPlayer.NoTargetsFoundException("Could not find any target that managed to launch build");
});
taskManager.Run();
}
catch (OperationFailedException ex)
{
UnityEngine.Debug.LogException(ex);
EditorUtility.DisplayDialog(ex.title, ex.Message, "Ok");
}
catch (OperationAbortedException)
{
Console.WriteLine("Deployment aborted");
}
catch (PostprocessBuildPlayer.NoTargetsFoundException)
{
throw new UnityException(string.Format("Could not find any valid targets to launch on for {0}", buildTarget));
}
catch (NotSupportedException)
{
IBuildPostprocessor buildPostProcessor = ModuleManager.GetBuildPostProcessor(targetGroup, buildTarget);
if (buildPostProcessor == null)
{
throw new UnityException(string.Format("Launching {0} build target via mono is not supported", buildTarget));
}
BuildLaunchPlayerArgs args;
args.target = buildTarget;
args.playerPackage = BuildPipeline.GetPlaybackEngineDirectory(buildTarget, options);
args.installPath = path;
args.productName = productName;
args.options = options;
buildPostProcessor.LaunchPlayer(args);
}
}
internal static bool DoesBuildTargetSupportIl2cpp(BuildTarget target)
{
return(BuildPipeline.GetPlaybackEngineDirectory(target, BuildOptions.Il2CPP) != string.Empty);
}
public static void MonoLink(BuildTarget buildTarget, string managedLibrariesDirectory, string[] input, string[] allAssemblies, RuntimeClassRegistry usedClasses)
{
Process process = MonoProcessUtility.PrepareMonoProcess(buildTarget, managedLibrariesDirectory);
string buildToolsDirectory = BuildPipeline.GetBuildToolsDirectory(buildTarget);
string text = null;
string frameWorksFolder = MonoInstallationFinder.GetFrameWorksFolder();
string text2 = Path.Combine(frameWorksFolder, MonoAssemblyStripping.StripperExe());
string text3 = Path.Combine(Path.GetDirectoryName(text2), "link.xml");
string text4 = Path.Combine(managedLibrariesDirectory, "output");
Directory.CreateDirectory(text4);
process.StartInfo.Arguments = "\"" + text2 + "\" -l none -c link";
for (int i = 0; i < input.Length; i++)
{
string str = input[i];
ProcessStartInfo expr_80 = process.StartInfo;
expr_80.Arguments = expr_80.Arguments + " -a \"" + str + "\"";
}
ProcessStartInfo expr_B3 = process.StartInfo;
string arguments = expr_B3.Arguments;
expr_B3.Arguments = string.Concat(new string[]
{
arguments,
" -out output -x \"",
text3,
"\" -d \"",
managedLibrariesDirectory,
"\""
});
string text5 = Path.Combine(buildToolsDirectory, "link.xml");
if (File.Exists(text5))
{
ProcessStartInfo expr_110 = process.StartInfo;
expr_110.Arguments = expr_110.Arguments + " -x \"" + text5 + "\"";
}
string text6 = Path.Combine(Path.GetDirectoryName(text2), "Core.xml");
if (File.Exists(text6))
{
ProcessStartInfo expr_151 = process.StartInfo;
expr_151.Arguments = expr_151.Arguments + " -x \"" + text6 + "\"";
}
string[] files = Directory.GetFiles(Path.Combine(Directory.GetCurrentDirectory(), "Assets"), "link.xml", SearchOption.AllDirectories);
string[] array = files;
for (int j = 0; j < array.Length; j++)
{
string str2 = array[j];
ProcessStartInfo expr_1A2 = process.StartInfo;
expr_1A2.Arguments = expr_1A2.Arguments + " -x \"" + str2 + "\"";
}
if (usedClasses != null)
{
text = MonoAssemblyStripping.GenerateBlackList(managedLibrariesDirectory, usedClasses, allAssemblies);
ProcessStartInfo expr_1E6 = process.StartInfo;
expr_1E6.Arguments = expr_1E6.Arguments + " -x \"" + text + "\"";
}
string path = Path.Combine(BuildPipeline.GetPlaybackEngineDirectory(EditorUserBuildSettings.activeBuildTarget, BuildOptions.None), "Whitelists");
string[] files2 = Directory.GetFiles(path, "*.xml");
for (int k = 0; k < files2.Length; k++)
{
string str3 = files2[k];
ProcessStartInfo expr_23B = process.StartInfo;
expr_23B.Arguments = expr_23B.Arguments + " -x \"" + str3 + "\"";
}
MonoProcessUtility.RunMonoProcess(process, "assemblies stripper", Path.Combine(text4, "mscorlib.dll"));
MonoAssemblyStripping.DeleteAllDllsFrom(managedLibrariesDirectory);
MonoAssemblyStripping.CopyAllDlls(managedLibrariesDirectory, text4);
string[] files3 = Directory.GetFiles(managedLibrariesDirectory);
for (int l = 0; l < files3.Length; l++)
{
string text7 = files3[l];
if (text7.Contains(".mdb"))
{
string path2 = text7.Replace(".mdb", string.Empty);
if (!File.Exists(path2))
{
FileUtil.DeleteFileOrDirectory(text7);
}
}
}
if (text != null)
{
FileUtil.DeleteFileOrDirectory(Path.Combine(managedLibrariesDirectory, text));
}
FileUtil.DeleteFileOrDirectory(text4);
}
public static void MonoLink(BuildTarget buildTarget, string managedLibrariesDirectory, string[] input, string[] allAssemblies, RuntimeClassRegistry usedClasses)
{
Process process = MonoProcessUtility.PrepareMonoProcess(buildTarget, managedLibrariesDirectory);
string buildToolsDirectory = BuildPipeline.GetBuildToolsDirectory(buildTarget);
string path2 = (string)null;
string path1 = Path.Combine(MonoInstallationFinder.GetFrameWorksFolder(), MonoAssemblyStripping.StripperExe());
string str1 = Path.Combine(Path.GetDirectoryName(path1), "link.xml");
string str2 = Path.Combine(managedLibrariesDirectory, "output");
Directory.CreateDirectory(str2);
process.StartInfo.Arguments = "\"" + path1 + "\" -l none -c link";
foreach (string str3 in input)
{
ProcessStartInfo startInfo = process.StartInfo;
string str4 = startInfo.Arguments + " -a \"" + str3 + "\"";
startInfo.Arguments = str4;
}
ProcessStartInfo startInfo1 = process.StartInfo;
string str5 = startInfo1.Arguments + " -out output -x \"" + str1 + "\" -d \"" + managedLibrariesDirectory + "\"";
startInfo1.Arguments = str5;
string path3 = Path.Combine(buildToolsDirectory, "link.xml");
if (File.Exists(path3))
{
ProcessStartInfo startInfo2 = process.StartInfo;
string str3 = startInfo2.Arguments + " -x \"" + path3 + "\"";
startInfo2.Arguments = str3;
}
string path4 = Path.Combine(Path.GetDirectoryName(path1), "Core.xml");
if (File.Exists(path4))
{
ProcessStartInfo startInfo2 = process.StartInfo;
string str3 = startInfo2.Arguments + " -x \"" + path4 + "\"";
startInfo2.Arguments = str3;
}
foreach (string file in Directory.GetFiles(Path.Combine(Directory.GetCurrentDirectory(), "Assets"), "link.xml", SearchOption.AllDirectories))
{
ProcessStartInfo startInfo2 = process.StartInfo;
string str3 = startInfo2.Arguments + " -x \"" + file + "\"";
startInfo2.Arguments = str3;
}
if (usedClasses != null)
{
path2 = MonoAssemblyStripping.GenerateBlackList(managedLibrariesDirectory, usedClasses, allAssemblies);
ProcessStartInfo startInfo2 = process.StartInfo;
string str3 = startInfo2.Arguments + " -x \"" + path2 + "\"";
startInfo2.Arguments = str3;
}
foreach (string file in Directory.GetFiles(Path.Combine(BuildPipeline.GetPlaybackEngineDirectory(EditorUserBuildSettings.activeBuildTarget, BuildOptions.None), "Whitelists"), "*.xml"))
{
ProcessStartInfo startInfo2 = process.StartInfo;
string str3 = startInfo2.Arguments + " -x \"" + file + "\"";
startInfo2.Arguments = str3;
}
MonoProcessUtility.RunMonoProcess(process, "assemblies stripper", Path.Combine(str2, "mscorlib.dll"));
MonoAssemblyStripping.DeleteAllDllsFrom(managedLibrariesDirectory);
MonoAssemblyStripping.CopyAllDlls(managedLibrariesDirectory, str2);
foreach (string file in Directory.GetFiles(managedLibrariesDirectory))
{
if (file.Contains(".mdb") && !File.Exists(file.Replace(".mdb", string.Empty)))
{
FileUtil.DeleteFileOrDirectory(file);
}
}
if (path2 != null)
{
FileUtil.DeleteFileOrDirectory(Path.Combine(managedLibrariesDirectory, path2));
}
FileUtil.DeleteFileOrDirectory(str2);
}
