/// <summary>
    /// Start a build using Unity's command line.
    /// </summary>
    public static async void StartCommandLineBuild()
    {
        // We don't need stack traces on all our logs. Makes things a lot easier to read.
        Application.SetStackTraceLogType(LogType.Log, StackTraceLogType.None);

        // default to HoloLens2
        var customBuildInfo = new CustomBuildInfo()
        {
            CustomType      = CustomBuildType.HoloLens2_ARM32,
            Silent          = true,
            AutoBuildAppx   = true,
            OutputDirectory = ""
        };

        // parse command line arguments
        ParseBuildCommandLine(ref customBuildInfo);

        Debug.LogFormat("Starting command line build for application ({0})...", customBuildInfo.CustomType);
        EditorAssemblyReloadManager.LockReloadAssemblies = true;

        bool success = false;

        try
        {
            UnityPlayerBuildTools.SyncSolution();
            await s_instance.BuildUnityPlayer(customBuildInfo);
        }
        catch (Exception e)
        {
            Debug.LogFormat(LogType.Error, LogOption.NoStacktrace, null, $"Build Failed!\n{e.Message}\n{e.StackTrace}");
            success = false;
        }

        Debug.LogFormat(LogType.Log, LogOption.NoStacktrace, null, $"Exiting command line build... Build success? {success}");
        EditorApplication.Exit(success ? 0 : 1);
    }
        public override void OnInspectorGUI()
        {
            base.OnInspectorGUI();

            serializedObject.Update();

            if (!(buildInfo is UwpBuildInfo uwpBuildInfo))
            {
                Debug.LogError($"{buildInfo.name} is not a {nameof(UwpBuildInfo)}");
                return;
            }

            EditorGUILayout.PropertyField(buildAppx);
            GUI.enabled = buildAppx.boolValue;
            EditorGUILayout.PropertyField(rebuildAppx);
            GUI.enabled = true;

            EditorGUILayout.BeginHorizontal();

            // Build config (and save setting, if it's changed)
            var curBuildConfigString = buildInfo.Configuration;

            WSABuildType buildConfigOption;

            if (curBuildConfigString.ToLower().Equals("master"))
            {
                buildConfigOption = WSABuildType.Master;
            }
            else if (curBuildConfigString.ToLower().Equals("release"))
            {
                buildConfigOption = WSABuildType.Release;
            }
            else
            {
                buildConfigOption = WSABuildType.Debug;
            }

            buildConfigOption = (WSABuildType)EditorGUILayout.EnumPopup("Build Configuration", buildConfigOption);

            var buildConfigString = buildConfigOption.ToString().ToLower();

            if (buildConfigString != curBuildConfigString)
            {
                buildInfo.Configuration = buildConfigString;
            }

            EditorGUILayout.PropertyField(platformArchitecture);
            EditorGUILayout.PropertyField(verbosity);
            EditorGUILayout.EndHorizontal();

            UwpAppxBuildTools.ValidateUwpSdk(true);

            // Build Appx
            if (GUILayout.Button("Build APPX"))
            {
                // Check if solution exists
                var slnFilename = Path.Combine(uwpBuildInfo.OutputDirectory, uwpBuildInfo.SolutionPath);

                if (File.Exists(slnFilename))
                {
                    EditorApplication.delayCall += () => UwpAppxBuildTools.BuildAppx(target as UwpBuildInfo);
                }
                else if (EditorUtility.DisplayDialog("Solution Not Found", "We couldn't find the solution. Would you like to Build it?", "Yes, Build", "No"))
                {
                    EditorApplication.delayCall += () => UnityPlayerBuildTools.BuildUnityPlayer();
                }
            }

            // Open Appx Solution
            if (GUILayout.Button("Open APPX solution in Visual Studio"))
            {
                var slnFilename = Path.Combine(uwpBuildInfo.OutputDirectory, uwpBuildInfo.SolutionPath);

                if (File.Exists(slnFilename))
                {
                    EditorApplication.delayCall += () => Process.Start(new FileInfo(slnFilename).FullName);
                }
                else if (EditorUtility.DisplayDialog(
                             "Solution Not Found",
                             "We couldn't find the Project's Solution. Would you like to Build the project now?",
                             "Yes, Build", "No"))
                {
                    EditorApplication.delayCall += () => UnityPlayerBuildTools.BuildUnityPlayer();
                }
            }

            // Open AppX packages location
            var appxDirectory = $"\\{PlayerSettings.productName}\\AppPackages";
            var appxBuildPath = Path.GetFullPath($"{BuildDeployPreferences.BuildDirectory}{appxDirectory}");

            GUI.enabled = !string.IsNullOrEmpty(appxBuildPath) && Directory.Exists(appxBuildPath);

            if (GUILayout.Button("Open APPX Packages Location"))
            {
                EditorApplication.delayCall += () => Process.Start("explorer.exe", $"/f /open,{appxBuildPath}");
            }

            GUI.enabled = true;

            serializedObject.ApplyModifiedProperties();
        }