Removed use of EditorUtility.DisplayProgressBar in Android Resolver

EditorUtility.DisplayProgressBar() is very flakey, it can end up in odd
states where it can never be cleared.

This removes the use of EditorUtility.DisplayProgressBar from the Android
Resolver, instead moving the progress bar display to the CommandLineDialog.
In addition, long running operations like labeling assets, have been made
asynchronous by scheduling each iteration on the main thread.

Finally, this leaves the Android Resolver window open if resolution fails,
results in one or more warnings or verbose logging is enabled so that it's
easier to inspect the failure logs.

Bug: 132070706
Change-Id: I31ed32659d3871f501aab7305cbfe4df99613e89

Author: Stewart Miles

source/PlayServicesResolver/src/CommandLineDialog.cs

@@ -148,10 +148,6 @@ public void Update(CommandLineDialog window)
                         bodyText = bodyTextHead + bodyText.Substring(carriageReturn + 1);
                     }
                     window.bodyText = bodyText;
-                    if (window.autoScrollToBottom)
-                    {
-                        window.scrollPosition.y = Mathf.Infinity;
-                    }
                     window.Repaint();
                 }
                 if (maxProgressLines > 0)
@@ -169,18 +165,20 @@ public void Update(CommandLineDialog window)
         public volatile float progress;
         public string progressTitle;
         public string progressSummary;
-        public volatile bool autoScrollToBottom;
         public Google.Logger logger = new Google.Logger();
 
+        /// <summary>
+        /// Whether a command is currently being executed.
+        /// </summary>
+        public bool RunningCommand { protected set; get; }
+
         /// <summary>
         /// Event delegate called from the Update() method of the window.
         /// </summary>
         public delegate void UpdateDelegate(CommandLineDialog window);
 
         public event UpdateDelegate UpdateEvent;
 
-        private bool progressBarVisible;
-
         /// <summary>
         /// Create a dialog box which can display command line output.
         /// </summary>
@@ -212,15 +210,6 @@ public static CommandLineDialog CreateCommandLineDialog(string title)
             }
         }
 
-        /// <summary>
-        /// Alternative Repaint() method that does not crash in batch mode.
-        /// </summary>
-        public new void Repaint() {
-            if (!ExecutionEnvironment.InBatchMode) {
-                base.Repaint();
-            }
-        }
-
         /// <summary>
         /// Alternative Close() method that does not crash in batch mode.
         /// </summary>
@@ -240,10 +229,42 @@ public override void Initialize()
             progressTitle = "";
             progressSummary = "";
             UpdateEvent = null;
-            progressBarVisible = false;
             autoScrollToBottom = false;
         }
 
+        /// <summary>
+        /// Set the progress bar status.
+        /// </summary>
+        /// <param name="title">Text to display before the progress bar.</param>
+        /// <param name="value">Progress bar value 0..1.</param>
+        /// <param name="summary">Text to display in the progress bar.</param>
+        public void SetProgress(string title, float value, string summary) {
+            progressTitle = title;
+            progress = value;
+            progressSummary = summary;
+            Repaint();
+        }
+
+        // Draw the GUI with an optional status bar.
+        protected override void OnGUI() {
+            summaryTextDisplay = true;
+            if (!String.IsNullOrEmpty(progressTitle)) {
+                summaryTextDisplay = false;
+                EditorGUILayout.BeginVertical();
+                EditorGUILayout.LabelField(progressTitle, EditorStyles.boldLabel);
+                var progressBarRect = EditorGUILayout.BeginVertical();
+                EditorGUILayout.LabelField(""); // Creates vertical space for the progress bar.
+                EditorGUI.ProgressBar(
+                    progressBarRect, progress,
+                    String.IsNullOrEmpty(progressSummary) ?
+                        String.Format("{0}%... ", (int)(progress * 100.0f)) : progressSummary);
+                EditorGUILayout.EndVertical();
+                EditorGUILayout.Space();
+                EditorGUILayout.EndVertical();
+            }
+            base.OnGUI();
+        }
+
         /// <summary>
         /// Asynchronously execute a command line tool in this window, showing progress
         /// and finally calling the specified delegate on completion from the main / UI thread.
@@ -273,38 +294,29 @@ public void RunAsync(
             // Connect the caller's IoHandler delegate to the reporter.
             reporter.DataHandler += ioHandler;
             // Disconnect the reporter when the command completes.
-            CommandLine.CompletionHandler reporterUpdateDisable =
-                (CommandLine.Result unusedResult) => { this.UpdateEvent -= reporter.Update; };
+            CommandLine.CompletionHandler reporterUpdateDisable = (unusedResult) => {
+                RunningCommand = false;
+                this.UpdateEvent -= reporter.Update;
+            };
             reporter.Complete += reporterUpdateDisable;
             logger.Log(String.Format(
                 "Executing command: {0} {1}", toolPath, arguments), level: LogLevel.Verbose);
+            RunningCommand = true;
             CommandLine.RunAsync(toolPath, arguments, reporter.CommandLineToolCompletion,
                                  workingDirectory: workingDirectory, envVars: envVars,
                                  ioHandler: reporter.AggregateLine);
         }
 
         /// <summary>
-        /// Call the update event from the UI thread, optionally display / hide the progress bar.
+        /// Call the update event from the UI thread.
         /// </summary>
         protected virtual void Update()
         {
             if (UpdateEvent != null) UpdateEvent(this);
-            if (progressTitle != "")
-            {
-                progressBarVisible = true;
-                EditorUtility.DisplayProgressBar(progressTitle, progressSummary,
-                                                 progress);
-            }
-            else if (progressBarVisible)
-            {
-                progressBarVisible = false;
-                EditorUtility.ClearProgressBar();
-            }
         }
 
         // Hide the progress bar if the window is closed.
         protected override void OnDestroy() {
-            if (progressBarVisible) EditorUtility.ClearProgressBar();
             base.OnDestroy();
         }
     }

source/PlayServicesResolver/src/DefaultResolver.cs

@@ -262,8 +262,8 @@ internal AndroidAbis AarDirectoryFindAbis(string aarDirectory) {
         /// to repack the processed AAR as a new AAR.</param>
         /// <param name="abis">ABIs in the AAR or null if it's universal.</param>
         /// <returns>true if successful, false otherwise.</returns>
-        internal virtual bool ProcessAar(string dir, string aarFile, bool antProject,
-                                         out AndroidAbis abis) {
+        internal bool ProcessAar(string dir, string aarFile, bool antProject,
+                                  out AndroidAbis abis) {
             PlayServicesResolver.Log(String.Format("ProcessAar {0} {1} antProject={2}",
                                                    dir, aarFile, antProject),
                                      level: LogLevel.Verbose);

source/PlayServicesResolver/src/GradleTemplateResolver.cs

@@ -108,9 +108,15 @@ private static bool CopySrcAars(ICollection<Dependency> dependencies) {
                     aarFiles.Add(targetFilename);
                     if (!File.Exists(targetFilename)) {
                         bool configuredAar = false;
-                        if (AssetDatabase.CopyAsset(srcaar, targetFilename) &&
+                        bool copiedAndLabeledAar = AssetDatabase.CopyAsset(srcaar, targetFilename);
+                        if (copiedAndLabeledAar) {
+                            var unlabeledAssets = new HashSet<string>();
                             PlayServicesResolver.LabelAssets(
-                                new [] { targetFilename }).Count == 0) {
+                                new [] { targetFilename },
+                                complete: (unlabeled) => { unlabeledAssets.UnionWith(unlabeled); });
+                            copiedAndLabeledAar = unlabeledAssets.Count == 0;
+                        }
+                        if (copiedAndLabeledAar) {
                             try {
                                 PluginImporter importer = (PluginImporter)AssetImporter.GetAtPath(
                                     targetFilename);

source/PlayServicesResolver/src/PlayServicesResolver.cs

@@ -1718,61 +1718,87 @@ internal static void OnSettingsChanged() {
         /// Label a set of assets that should be managed by this plugin.
         /// </summary>
         /// <param name="assetPaths">Set of assets to label.</param>
+        /// <param name="complete">Called when the operation is complete with the set of assets
+        /// that could not be labeled.</param>
+        /// <param name="synchronous">Whether to block until asset labeling is complete.</param>
+        /// <param name="progressUpdate">Called with the progress (0..1) and message that indicates
+        /// processing progress.</param>
         /// <param name="displayWarning">Whether to display a warning if assets can't be
         /// labeled.</param>
         /// <param name="recursive">Whether to label assets in subdirectories of the specified
         /// assetPaths.</param>
-        /// <returns>List of assets that could not be labeled.</returns>
-        internal static HashSet<string> LabelAssets(IEnumerable<string> assetPaths,
-                                                    bool displayWarning = true,
-                                                    bool recursive = false) {
-            var assetsWithoutAssetImporter = new HashSet<string>(assetPaths);
-            if (assetsWithoutAssetImporter.Count == 0) return assetsWithoutAssetImporter;
+        /// <returns></returns>
+        internal static void LabelAssets(IEnumerable<string> assetPaths,
+                                         Action<HashSet<string>> complete = null,
+                                         bool synchronous = true,
+                                         Action<float, string> progressUpdate = null,
+                                         bool displayWarning = true,
+                                         bool recursive = false) {
+            var assetsWithoutAssetImporter = new HashSet<string>();
             var projectDataFolder = Path.GetFullPath(Application.dataPath);
-            foreach (var assetPath in new List<string>(assetsWithoutAssetImporter)) {
-                // Ignore asset meta files which are used to store the labels and files that
-                // are not in the project.
-                var fullAssetPath = Path.GetFullPath(assetPath);
-                if (assetPath.EndsWith(".meta") || !fullAssetPath.StartsWith(projectDataFolder)) {
-                    assetsWithoutAssetImporter.Remove(assetPath);
-                    continue;
-                }
+            var assetsToProcess = new List<string>(assetPaths);
+            int totalAssets = assetsToProcess.Count;
+            RunOnMainThread.PollOnUpdateUntilComplete(() => {
+                    var remainingAssets = assetsToProcess.Count;
+                    // Display summary of processing and call the completion function.
+                    if (remainingAssets == 0) {
+                        if (assetsWithoutAssetImporter.Count > 0 && displayWarning) {
+                            Log(String.Format(
+                                "Failed to add tracking label {0} to some assets.\n\n" +
+                                "The following files will not be managed by this module:\n" +
+                                "{1}\n", ManagedAssetLabel,
+                                String.Join(
+                                    "\n", new List<string>(assetsWithoutAssetImporter).ToArray())),
+                                level: LogLevel.Warning);
+                        }
+                        if (complete != null) complete(assetsWithoutAssetImporter);
+                        return true;
+                    }
+                    var assetPath = assetsToProcess[0];
+                    assetsToProcess.RemoveAt(0);
+                    // Ignore asset meta files which are used to store the labels and files that
+                    // are not in the project.
+                    var fullAssetPath = Path.GetFullPath(assetPath);
+                    if (assetPath.EndsWith(".meta") ||
+                        !fullAssetPath.StartsWith(projectDataFolder)) {
+                        return false;
+                    }
 
-                // Get the relative path of this asset.
-                var relativeAssetPath = Path.Combine(
-                    Path.GetFileName(projectDataFolder),
-                    fullAssetPath.Substring(projectDataFolder.Length +1));
+                    // Get the relative path of this asset.
+                    var relativeAssetPath = Path.Combine(
+                        Path.GetFileName(projectDataFolder),
+                        fullAssetPath.Substring(projectDataFolder.Length +1));
 
-                // If the asset is a directory, add labels to the contents.
-                if (recursive && Directory.Exists(relativeAssetPath)) {
-                    assetsWithoutAssetImporter.UnionWith(
-                        LabelAssets(Directory.GetFileSystemEntries(relativeAssetPath),
-                                    displayWarning: false));
-                }
+                    if (progressUpdate != null) {
+                        progressUpdate((float)(totalAssets - remainingAssets) /
+                                       (float)totalAssets, relativeAssetPath);
+                    }
 
-                // It's likely files have been added or removed without using AssetDatabase methods
-                // so (re)import the asset to make sure it's in the AssetDatabase.
-                AssetDatabase.ImportAsset(relativeAssetPath,
-                                          options: ImportAssetOptions.ForceSynchronousImport);
-
-                // Add the label to the asset.
-                AssetImporter importer = AssetImporter.GetAtPath(relativeAssetPath);
-                if (importer != null) {
-                    var labels = new HashSet<string>(AssetDatabase.GetLabels(importer));
-                    labels.Add(ManagedAssetLabel);
-                    AssetDatabase.SetLabels(importer, (new List<string>(labels)).ToArray());
-                    assetsWithoutAssetImporter.Remove(assetPath);
-                }
-            }
-            if (assetsWithoutAssetImporter.Count > 0 && displayWarning) {
-                Log(String.Format(
-                    "Failed to add tracking label {0} to some assets.\n\n" +
-                    "The following files will not be managed by this module:\n" +
-                    "{1}\n", ManagedAssetLabel,
-                    String.Join("\n", new List<string>(assetsWithoutAssetImporter).ToArray())),
-                    level: LogLevel.Warning);
-            }
-            return assetsWithoutAssetImporter;
+                    // If the asset is a directory, add labels to the contents.
+                    if (recursive && Directory.Exists(relativeAssetPath)) {
+                        var contents = new List<string>(
+                            Directory.GetFileSystemEntries(relativeAssetPath));
+                        totalAssets += contents.Count;
+                        assetsToProcess.AddRange(contents);
+                        return false;
+                    }
+
+                    // It's likely files have been added or removed without using AssetDatabase
+                    // methods so (re)import the asset to make sure it's in the AssetDatabase.
+                    AssetDatabase.ImportAsset(relativeAssetPath,
+                                              options: ImportAssetOptions.ForceSynchronousImport);
+
+                    // Add the label to the asset.
+                    AssetImporter importer = AssetImporter.GetAtPath(relativeAssetPath);
+                    if (importer != null) {
+                        var labels = new HashSet<string>(AssetDatabase.GetLabels(importer));
+                        labels.Add(ManagedAssetLabel);
+                        AssetDatabase.SetLabels(importer, (new List<string>(labels)).ToArray());
+                    } else {
+                        assetsWithoutAssetImporter.Add(assetPath);
+                    }
+                    return false;
+                }, synchronous: synchronous);
         }
 
         /// <summary>