Implement EditorInitializer

Add a utility class which helps to call initialization function
only when the condition is met on the main thread.

Also, change IOSResolver and PlayServicesResolver to utilize this.

Bug: 154730431
Change-Id: If0eb71883ce6680aa55051a9f7b9c700e5a93ba5

Author: chkuang-g

source/AndroidResolver/src/PlayServicesResolver.cs

@@ -901,40 +901,20 @@ public static bool AutomaticResolutionEnabled {
         /// Initializes the <see cref="GooglePlayServices.PlayServicesResolver"/> class.
         /// </summary>
         static PlayServicesResolver() {
-            // Cache the flag to prevent string comparison in every frame during
-            // PollOnUpdateUntilComplete()
-            bool isExecuteMethodEnabled =  ExecutionEnvironment.ExecuteMethodEnabled;
-
-            // Delay initialization until the build target is iOS and the editor is not in play
+            // Delay initialization until the build target is Android and the editor is not in play
             // mode.
-            RunOnMainThread.PollOnUpdateUntilComplete(() => {
-                if (EditorUserBuildSettings.activeBuildTarget != BuildTarget.Android ||
-                    EditorApplication.isPlayingOrWillChangePlaymode) {
-                    // If Unity is launched with -executeMethod, in some Unity versions, editor
-                    // update will never be called. As a result, PollOnUpdateUntilComplete() will
-                    // attempt to call this poll function repeating on current thread until it
-                    // returns true.  Therefore, return true immediately and stop the polling in
-                    // executeMethod mode.
-                    return isExecuteMethodEnabled;
-                }
-                Initialize();
-                return true;
-            });
+            EditorInitializer.InitializeOnMainThread(condition: () => {
+                return EditorUserBuildSettings.activeBuildTarget == BuildTarget.Android &&
+                        !EditorApplication.isPlayingOrWillChangePlaymode;
+            }, initializer: Initialize, name: "PlayServicesResolver", logger: logger);
 
         }
 
-        /// <summary>
-        /// Whether Android Resolver have been initialized.
-        /// </summary>
-        private static bool isInitialized = false;
-
         /// <summary>
         /// Initialize the module. This should be called on the main thread only if
         /// current active build target is Android and not in play mode.
         /// </summary>
-        private static void Initialize() {
-            if (isInitialized) return;
-
+        private static bool Initialize() {
             if ( EditorUserBuildSettings.activeBuildTarget != BuildTarget.Android ) {
                 throw new Exception("PlayServiceResolver.Initialize() is called when active " +
                         "build target is not Android. This should never happen. If it does, " +
@@ -967,8 +947,7 @@ private static void Initialize() {
 
             if (SettingsDialogObj.EnableAutoResolution) LinkAutoResolution();
 
-            isInitialized = true;
-            Log("Android Resolver Initialized", level: LogLevel.Verbose);
+            return true;
         }
 
         // Unregister events to monitor build system changes for the Android Resolver and other

source/IOSResolver/src/IOSResolver.cs

@@ -658,38 +658,19 @@ static IOSResolver() {
         // so we install the DLL loader first then try using the Xcode module.
         RemapXcodeExtension();
 
-        // Cache the flag to prevent string comparison in every frame during
-        // PollOnUpdateUntilComplete()
-        bool isExecuteMethodEnabled =  ExecutionEnvironment.ExecuteMethodEnabled;
-
-        // Delay initialization until the build target is iOS and the editor is not in play mode.
-        RunOnMainThread.PollOnUpdateUntilComplete(() => {
-            if (EditorUserBuildSettings.activeBuildTarget != BuildTarget.iOS ||
-                EditorApplication.isPlayingOrWillChangePlaymode) {
-                // If Unity is launched with -executeMethod, in some Unity versions, editor
-                // update will never be called. As a result, PollOnUpdateUntilComplete() will
-                // attempt to call this poll function repeating on current thread until it returns
-                // true.  Therefore, return true immediately and stop the polling in executeMethod
-                // mode.
-                return isExecuteMethodEnabled;
-            }
-            Initialize();
-            return true;
-        });
+        // Delay initialization until the build target is iOS and the editor is not in play
+        // mode.
+        EditorInitializer.InitializeOnMainThread(condition: () => {
+            return EditorUserBuildSettings.activeBuildTarget == BuildTarget.iOS &&
+                    !EditorApplication.isPlayingOrWillChangePlaymode;
+        }, initializer: Initialize, name: "IOSResolver", logger: logger);
     }
 
-    /// <summary>
-    /// Whether iOSResolver have been initialized.
-    /// </summary>
-    private static bool isInitialized = false;
-
     /// <summary>
     /// Initialize the module. This should be called on the main thread only if
     /// current active build target is iOS and not in play mode.
     /// </summary>
-    private static void Initialize() {
-        if (isInitialized) return;
-
+    private static bool Initialize() {
         if ( EditorUserBuildSettings.activeBuildTarget != BuildTarget.iOS ) {
             throw new Exception("IOSResolver.Initialize() is called when active build target " +
                     "is not iOS. This should never happen.  If it does, please report to the " +
@@ -757,9 +738,8 @@ exception is TypeInitializationException ||
                     }
                 });
         }
-        isInitialized = true;
 
-        Log("IOSResolver Initialized", verbose: true);
+        return true;
     }
 
     /// <summary>

source/VersionHandlerImpl/VersionHandlerImpl.csproj

@@ -56,6 +56,7 @@
     <Compile Include="src\DialogWindow.cs" />
     <Compile Include="src\Logger.cs" />
     <Compile Include="src\ExecutionEnvironment.cs" />
+    <Compile Include="src\EditorInitializer.cs" />
     <Compile Include="src\EditorMeasurement.cs" />
     <Compile Include="src\FileUtils.cs" />
     <Compile Include="src\MultiSelectWindow.cs" />

source/VersionHandlerImpl/src/EditorInitializer.cs

@@ -0,0 +1,81 @@
+// <copyright file="EditorInitializer.cs" company="Google Inc.">
+// Copyright (C) 2020 Google Inc. All Rights Reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+
+namespace Google {
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+using UnityEngine;
+using UnityEditor;
+
+/// <summary>
+/// Utility to initialize classes used only in Unity Editor.
+/// </summary>
+static public class EditorInitializer {
+    /// <summary>
+    /// Call initialization function on the main thread only when the condition is met.
+    /// </summary>
+    /// <param name="condition">When it returns true, call the initializer once.
+    /// If null, initializer will be called in the next editor update.</param>
+    /// <param name="initializer">Initialization function to be called when condition is met.
+    /// </params>
+    /// <param name="name">Name of the component to be initialized, for debug purpose.</param>
+    /// <param name="logger">Logger to be used to report when initialization is finished.</param>
+    public static void InitializeOnMainThread(
+            Func<bool> condition, Func<bool> initializer, string name, Logger logger = null) {
+        if (initializer == null) return;
+
+        // Cache the flag to prevent string comparison in every frame during
+        // PollOnUpdateUntilComplete()
+        bool isExecuteMethodEnabled =  ExecutionEnvironment.ExecuteMethodEnabled;
+
+        // Delay initialization until condition is met.
+        RunOnMainThread.PollOnUpdateUntilComplete(() => {
+            if (condition != null && !condition()) {
+                // If Unity is launched with -executeMethod, in some Unity versions, editor
+                // update will never be called. As a result, PollOnUpdateUntilComplete() will
+                // attempt to call this poll function repeating on current thread until it returns
+                // true.  Therefore, return true immediately and stop the polling in executeMethod
+                // mode.
+                return isExecuteMethodEnabled;
+            }
+            bool result = false;
+
+            try {
+                result = initializer();
+            } catch (Exception e) {
+                string errorMsg = String.Format("Exception thrown when initializing {0}: {1}",
+                                    name, e.ToString());
+                if (logger != null) {
+                    logger.Log(errorMsg, level: LogLevel.Error);
+                } else {
+                    Debug.LogError(errorMsg);
+                }
+            }
+
+            if (logger != null) {
+                logger.Log(String.Format("{0} initialization {1}", name,
+                    result ? "succeeded." : "failed." ),
+                    level: result ? LogLevel.Verbose : LogLevel.Error);
+            }
+
+            return true;
+        });
+    }
+}
+}