Added support for synchronous resolution.

* Added RunOnMainThread.TryExecuteAll to allow users to pump the
  job queue when a job is scheduled from the main thread.
* Fixed re-entrant behavior in RunOnMainThread when running a series of
  jobs on the main thread in batch mode.  This caused the stack to grow for
  each executed job.
* Modified CommandLine and CommandLineDialog classes to support synchronous
  execution.
* Added integration test case for synchronous resolution.
* Deprecated UnityCompat.InBatchMode and removed duplicate implementation in
  JarResolverLib.  UnityCompat.InBatchMode is kept in place for now as it's
  a public API in use by some other plugins.

Fixes #120
Bug: 112757664
Change-Id: I380bab695fdf98e70a0a5dbbeeeb6b95b2db7e6d

Author: Stewart Miles

source/JarResolverLib/src/Google.JarResolver/PlayServicesSupport.cs

@@ -99,26 +99,6 @@ public enum LogLevel {
              "or the \"Unity > Preferences > External Tools\" menu option on OSX. " +
              "Alternatively, set the ANDROID_HOME environment variable");
 
-        /// <summary>
-        /// Delegate used to determine whether an AAR should be exploded.
-        /// </summary>
-        /// <param name="aarPath">Path to the AAR file to examine.</param>
-        /// <returns>True if the AAR should be exploded, false otherwise.</returns>
-        public delegate bool ExplodeAar(string aarPath);
-
-        /// <summary>
-        /// Whether the editor was launched in batch mode.
-        /// </summary>
-        internal static bool InBatchMode {
-            get {
-#if UNITY_EDITOR
-                return System.Environment.CommandLine.Contains("-batchmode");
-#else
-                return true;
-#endif  // UNITY_EDITOR
-            }
-        }
-
         // Map of common dependencies to Android SDK packages.
         private static List<KeyValuePair<Regex, string>> CommonPackages =
             new List<KeyValuePair<Regex, string>> {
@@ -226,7 +206,7 @@ internal static PlayServicesSupport CreateInstance(
         /// logging enabled.</param>
         internal static void Log(string message, LogLevel level = LogLevel.Info,
                                  bool verbose = false) {
-            if (logger != null && (!verbose || verboseLogging || InBatchMode)) {
+            if (logger != null && (!verbose || verboseLogging)) {
                 logger(message, level);
             }
         }

source/PlayServicesResolver/src/CommandLine.cs

@@ -119,7 +119,8 @@ public static StreamData Empty
         /// </summary>
         /// <param name="toolPath">Tool to execute.</param>
         /// <param name="arguments">String to pass to the tools' command line.</param>
-        /// <param name="completionDelegate">Called when the tool completes.</param>
+        /// <param name="completionDelegate">Called when the tool completes.  This is always
+        /// called from the main thread.</param>
         /// <param name="workingDirectory">Directory to execute the tool from.</param>
         /// <param name="envVars">Additional environment variables to set for the command.</param>
         /// <param name="ioHandler">Allows a caller to provide interactive input and also handle
@@ -132,10 +133,10 @@ public static void RunAsync(
             Action action = () => {
                 Result result = Run(toolPath, arguments, workingDirectory, envVars: envVars,
                                     ioHandler: ioHandler);
-                completionDelegate(result);
+                RunOnMainThread.Run(() => { completionDelegate(result);});
             };
             if (ExecutionEnvironment.InBatchMode) {
-                action();
+                RunOnMainThread.Run(action);
             } else {
                 Thread thread = new Thread(new ThreadStart(action));
                 thread.Start();

source/PlayServicesResolver/src/CommandLineDialog.cs

@@ -104,9 +104,7 @@ public void CommandLineToolCompletion(CommandLine.Result result)
                     String.Format("Command completed: {0}", result.message),
                     level: LogLevel.Verbose);
                 this.result = result;
-                if (ExecutionEnvironment.InBatchMode) {
-                    RunOnMainThread.Run(() => { SignalComplete(); });
-                }
+                SignalComplete();
             }
 
             /// <summary>

source/PlayServicesResolver/src/PlayServicesResolver.cs

@@ -20,6 +20,7 @@ namespace GooglePlayServices
     using System.Collections.Generic;
     using System.IO;
     using System.Text.RegularExpressions;
+    using System.Threading;
     using System.Xml;
     using Google;
     using Google.JarResolver;
@@ -815,6 +816,20 @@ private static void OnPostprocessAllAssets(string[] importedAssets,
             }
         }
 
+        /// <summary>
+        /// If auto-resolution is enabled, run resolution synchronously before building the
+        /// application.
+        /// </summary>
+        [UnityEditor.Callbacks.PostProcessSceneAttribute(0)]
+        private static void OnPostProcessScene() {
+            if (Resolver.AutomaticResolutionEnabled()) {
+                Log("Starting auto-resolution before scene build...");
+                bool success = ResolveSync(false);
+                Log(String.Format("Android resolution {0}.", success ? "succeeded" : "failed"),
+                    level: LogLevel.Verbose);
+            }
+        }
+
         /// <summary>
         /// Schedule auto-resolution.
         /// </summary>
@@ -1145,6 +1160,16 @@ private static bool DeleteFiles(IEnumerable<string> filenames)
             return deletedFiles;
         }
 
+        /// <summary>
+        /// Signal completion of a resolve job.
+        /// </summary>
+        /// <param name="completion">Action to call.</param>
+        private static void SignalResolveJobComplete(Action completion) {
+            resolutionJobs.RemoveAll((jobInfo) => { return jobInfo == null; });
+            completion();
+            ExecuteNextResolveJob();
+        }
+
         /// <summary>
         /// Execute the next resolve job on the queue.
         /// </summary>
@@ -1190,6 +1215,31 @@ public static void Resolve(Action resolutionComplete = null,
                             }, false);
         }
 
+        /// <summary>
+        /// Resolve dependencies synchronously.
+        /// </summary>
+        /// <param name="forceResolution">Whether resolution should be executed when no dependencies
+        /// have changed.  This is useful if a dependency specifies a wildcard in the version
+        /// expression.</param>
+        /// <returns>true if successful, false otherwise.</returns>
+        public static bool ResolveSync(bool forceResolution) {
+            bool successful = false;
+            var completeEvent = new ManualResetEvent(false);
+            ScheduleResolve(forceResolution, (success) => {
+                    successful = success;
+                    completeEvent.Set();
+                }, false);
+            // We poll from this thread to pump the update queue if the scheduled job isn't
+            // executed immediately.
+            while (true) {
+                RunOnMainThread.TryExecuteAll();
+                if (completeEvent.WaitOne(100 /* 100ms poll interval */)) {
+                    break;
+                }
+            }
+            return successful;
+        }
+
         /// <summary>
         /// Schedule resolution of dependencies.  If resolution is currently active this queues up
         /// the requested resolution action to execute when the current resolution is complete.
@@ -1206,25 +1256,25 @@ private static void ScheduleResolve(bool forceResolution,
                                             bool isAutoResolveJob) {
             bool firstJob;
             lock (resolutionJobs) {
-                firstJob = resolutionJobs.Count == 0;
-
                 // Remove the scheduled action which enqueues an auto-resolve job.
                 RunOnMainThread.Cancel(autoResolveJobId);
                 autoResolveJobId = 0;
                 // Remove any enqueued auto-resolve jobs.
                 resolutionJobs.RemoveAll((jobInfo) => {
                         return jobInfo != null && jobInfo.IsAutoResolveJob;
                     });
+                firstJob = resolutionJobs.Count == 0;
 
                 resolutionJobs.Add(
                     new ResolutionJob(
                         isAutoResolveJob,
                         () => {
                             ResolveUnsafe(resolutionComplete: (success) => {
-                                    if (resolutionCompleteWithResult != null) {
-                                        resolutionCompleteWithResult(success);
-                                    }
-                                    ExecuteNextResolveJob();
+                                    SignalResolveJobComplete(() => {
+                                            if (resolutionCompleteWithResult != null) {
+                                                resolutionCompleteWithResult(success);
+                                            }
+                                        });
                                 },
                                 forceResolution: forceResolution);
                         }));
@@ -1300,7 +1350,7 @@ private static void ResolveUnsafe(Action<bool> resolutionComplete = null,
                                               succeeded ? "Succeeded" : "Failed",
                                               lastError), level: LogLevel.Verbose);
                             if (resolutionComplete != null) {
-                                resolutionComplete(succeeded);
+                                RunOnMainThread.Run(() => { resolutionComplete(succeeded); });
                             }
                         });
                 });
@@ -1377,7 +1427,9 @@ internal static void OnSettingsChanged() {
             }
             previousInstallAndroidPackages =
                 GooglePlayServices.SettingsDialog.InstallAndroidPackages;
-            PlayServicesSupport.verboseLogging = GooglePlayServices.SettingsDialog.VerboseLogging;
+            PlayServicesSupport.verboseLogging =
+                GooglePlayServices.SettingsDialog.VerboseLogging ||
+                ExecutionEnvironment.InBatchMode;
             logger.Verbose = GooglePlayServices.SettingsDialog.VerboseLogging;
             if (Resolver != null) {
                 PatchAndroidManifest(UnityCompat.ApplicationId, null);

source/PlayServicesResolver/src/UnityCompat.cs

@@ -119,6 +119,7 @@ public static int GetAndroidTargetSDKVersion() {
     /// <summary>
     /// Returns whether the editor is running in batch mode.
     /// </summary>
+    [ObsoleteAttribute("InBatchMode is obsolete, use ExecutionEnvironment.InBatchMode instead")]
     public static bool InBatchMode { get { return ExecutionEnvironment.InBatchMode; } }
 
     private static Type AndroidSDKToolsClass {

source/PlayServicesResolver/test/resolve_async/Assets/PlayServicesResolver/Editor/TestResolveAsync.cs

@@ -171,6 +171,15 @@ static TestResolveAsync() {
                                 null, testCase, testCaseComplete);
                     }
                 },
+                new TestCase {
+                    Name = "ResolveForGradleBuildSystemSync",
+                    Method = (testCase, testCaseComplete) => {
+                        ClearDependencies();
+                        SetupDependencies(testCase, testCaseComplete);
+                        Resolve("Gradle", false, "ExpectedArtifacts/NoExport/Gradle",
+                                null, testCase, testCaseComplete, synchronous: true);
+                    }
+                },
                 new TestCase {
                     Name = "ResolveForInternalBuildSystem",
                     Method = (testCase, testCaseComplete) => {
@@ -386,10 +395,10 @@ private static void ExecuteNextTestCase() {
     /// Called when the Version Handler has enabled all managed plugins in a project.
     /// </summary>
     public static void VersionHandlerReady() {
+        UnityEngine.Debug.Log("VersionHandler is ready.");
         Google.VersionHandler.UpdateCompleteMethods = null;
         // If this has already been initialize this session, do not start tests again.
         if (SetInitialized()) return;
-        UnityEngine.Debug.Log("Plugin is ready.");
         // Start executing tests.
         ExecuteNextTestCase();
     }
@@ -478,9 +487,11 @@ private static void SetupDependencies(TestCase testCase,
     /// should be selected.</param>
     /// <param name="testCase">Object executing this method.</param>
     /// <param name="testCaseComplete">Called with the test result.</param>
+    /// <param name="synchronous">Whether the resolution should be executed synchronously.</param>
     private static void Resolve(string androidBuildSystem, bool exportProject,
                                 string expectedAssetsDir, string targetAbis,
-                                TestCase testCase, Action<TestCaseResult> testCaseComplete) {
+                                TestCase testCase, Action<TestCaseResult> testCaseComplete,
+                                bool synchronous = false) {
         // Set the Android target ABIs.
         AndroidAbisCurrentString = targetAbis;
         // Try setting the build system if this version of Unity supports it.
@@ -527,11 +538,18 @@ private static void Resolve(string androidBuildSystem, bool exportProject,
                         });
                 }, true);
         };
-        Google.VersionHandler.InvokeStaticMethod(
-            AndroidResolverClass, "Resolve", args: null,
-            namedArgs: new Dictionary<string, object>() {
-                {"resolutionCompleteWithResult", completeWithResult}
-            });
+        if (synchronous) {
+            bool success = (bool)Google.VersionHandler.InvokeStaticMethod(
+                AndroidResolverClass, "ResolveSync", args: new object[] { true },
+                namedArgs: null);
+            completeWithResult(success);
+        } else {
+            Google.VersionHandler.InvokeStaticMethod(
+                AndroidResolverClass, "Resolve", args: null,
+                namedArgs: new Dictionary<string, object>() {
+                    {"resolutionCompleteWithResult", completeWithResult}
+                });
+        }
     }
 
     /// <summary>