Fixed dialog window may be cleared when Unity reload assemblies.

When Unity reload assemblies, opened EditorWindow will remain on
the screen but the content of the EditorWindow may be clear if
the data cannot be serialized, ex. delegate.

This fix alleviate the issue with the following approaches:
* Close the dialog before Unity reload assemblies.
* Try to postpone analytics event reporting after Unity finishes
  compiling.

Change-Id: I6f06a8aeb75af1f9afd694e4e8828e437a29c11d

Author: chkuang-g

source/VersionHandler/src/VersionHandler.cs

@@ -554,6 +554,87 @@ public static object InvokeMethod(
         }
         return foundMethod.Invoke(objectInstance, parameterValues);
     }
+
+    /// <summary>
+    /// Call a method on a static event.
+    /// </summary>
+    /// <param name="type">Class to call the method on.</param>
+    /// <param name="eventName">The name of the event.</param>
+    /// <param name="action">Action to add/remove from the event.</param>
+    /// <param name="getMethod">The func to get the method on the event.</param>
+    /// <returns>True if the method is called successfully.</returns>
+    private static bool InvokeStaticEventMethod(Type type, string eventName, Action action,
+                                                Func<EventInfo, MethodInfo> getMethod) {
+        EventInfo eventInfo = type.GetEvent(eventName);
+        if (eventInfo != null) {
+            MethodInfo method = getMethod(eventInfo);
+            Delegate d = Delegate.CreateDelegate(
+                    eventInfo.EventHandlerType, action.Target, action.Method);
+            System.Object[] args = { d };
+            if (method.IsStatic) {
+                method.Invoke(null, args);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// <summary>
+    /// Call adder method on a static event.
+    /// </summary>
+    /// <param name="type">Class to call the method on.</param>
+    /// <param name="eventName">The name of the event.</param>
+    /// <param name="action">Action to add from the event.</param>
+    /// <returns>True if the action is added successfully.</returns>
+    public static bool InvokeStaticEventAddMethod(Type type, string eventName, Action action) {
+        return InvokeStaticEventMethod(type, eventName, action,
+                                       eventInfo => eventInfo.GetAddMethod());
+    }
+
+    /// <summary>
+    /// Call remover method on a static event.
+    /// </summary>
+    /// <param name="type">Class to call the method on.</param>
+    /// <param name="eventName">The name of the event.</param>
+    /// <param name="action">Action to remove from the event.</param>
+    /// <returns>True if the action is removed successfully.</returns>
+    public static bool InvokeStaticEventRemoveMethod(Type type, string eventName, Action action) {
+        return InvokeStaticEventMethod(type, eventName, action,
+                                       eventInfo => eventInfo.GetRemoveMethod());
+    }
+
+    // Name of UnityEditor.AssemblyReloadEvents.beforeAssemblyReload event.
+    private const string BeforeAssemblyReloadEventName = "beforeAssemblyReload";
+
+    /// <summary>
+    /// Register for beforeAssemblyReload event.
+    /// Note that AssemblyReloadEvents is only availabe from Unity 2017.
+    /// </summary>
+    /// <param name="action">Action to register for.</param>
+    /// <returns>True if the action is registered successfully.</returns>
+    public static bool RegisterBeforeAssemblyReloadEvent(Action action) {
+        Type eventType = VersionHandler.FindClass("UnityEditor",
+                                                  "UnityEditor.AssemblyReloadEvents");
+        if (eventType != null) {
+            return InvokeStaticEventAddMethod(eventType, BeforeAssemblyReloadEventName, action);
+        }
+        return false;
+    }
+
+    /// <summary>
+    /// Unregister for beforeAssemblyReload event.
+    /// Note that AssemblyReloadEvents is only availabe from Unity 2017.
+    /// </summary>
+    /// <param name="action">Action to unregister for.</param>
+    /// <returns>True if the action is unregistered successfully.</returns>
+    public static bool UnregisterBeforeAssemblyReloadEvent(Action action) {
+        Type eventType = VersionHandler.FindClass("UnityEditor",
+                                                  "UnityEditor.AssemblyReloadEvents");
+        if (eventType != null) {
+            return InvokeStaticEventRemoveMethod(eventType, BeforeAssemblyReloadEventName, action);
+        }
+        return false;
+    }
 }
 
 }  // namespace Google

source/VersionHandler/test/reflection/Assets/PlayServicesResolver/Editor/TestReflection.cs

@@ -25,6 +25,10 @@
 public class Greeter {
     private string name;
 
+    public event Action instanceEvent;
+
+    static public event Action staticEvent;
+
     public Greeter(string name) {
         this.name = name;
     }
@@ -77,6 +81,18 @@ public string HelloWithCustomerNameAndPronoun(string customerName,
         return Greeter.GenericHelloWithCustomerNameAndPronoun(customerName,
                                                               pronoun: pronoun) + MyNameIs();
     }
+
+    public static void InvokeStaticEvent() {
+        if (staticEvent != null) {
+            staticEvent.Invoke();
+        }
+    }
+
+    public void InvokeInstanceEvent() {
+        if (instanceEvent != null) {
+            instanceEvent.Invoke();
+        }
+    }
 }
 
 [UnityEditor.InitializeOnLoad]
@@ -105,6 +121,7 @@ static TestReflection() {
                     TestInvokeInstanceMethodWithNoArgs,
                     TestInvokeInstanceMethodWithNamedArgDefault,
                     TestInvokeInstanceMethodWithNamedArg,
+                    TestInvokeStaticEventMethod,
                  }) {
             var testName = test.Method.Name;
             Exception exception = null;
@@ -257,4 +274,61 @@ static bool TestInvokeInstanceMethodWithNamedArg() {
                               new object[] { "Smith" },
                               new Dictionary<string, object> { { "pronoun", "Mrs" } }));
     }
+
+    // Check if the delegate is properly added/removed from the given event using the function to
+    // test.
+    static bool CheckEvent(Func<Action, bool> funcToTest, Action invokeEvent,
+                           bool expectSuccess, bool expectInvoked) {
+
+        bool invoked = false;
+
+        Action actionToInvoke = () => {
+            invoked = true;
+        };
+
+        bool result = funcToTest(actionToInvoke);
+        if (result != expectSuccess){
+            throw new Exception(
+                    String.Format("Expect funcToTest returns '{0}', but actually returned '{1}'",
+                            expectSuccess, result));
+        }
+        invokeEvent();
+        if ( invoked != expectInvoked) {
+            throw new Exception(String.Format(
+                    "Expect event invoked: {0}, but actually event invoked: {1}",
+                            expectInvoked, invoked));
+        }
+
+        return true;
+    }
+
+    // Test adding/removing delegate to a static event.
+    static bool TestInvokeStaticEventMethod() {
+        CheckEvent( funcToTest: (action) =>
+                VersionHandler.InvokeStaticEventAddMethod(typeof(Greeter), "staticEvent", action),
+                invokeEvent: Greeter.InvokeStaticEvent,
+                expectSuccess: true,
+                expectInvoked: true);
+
+        CheckEvent( funcToTest: (action) =>
+                VersionHandler.InvokeStaticEventRemoveMethod(typeof(Greeter), "staticEvent",
+                        action),
+                invokeEvent: Greeter.InvokeStaticEvent,
+                expectSuccess: true,
+                expectInvoked: false);
+
+        CheckEvent( funcToTest: (action) =>
+                VersionHandler.InvokeStaticEventAddMethod(typeof(Greeter), "foo", action),
+                invokeEvent: Greeter.InvokeStaticEvent,
+                expectSuccess: false,
+                expectInvoked: false);
+
+        CheckEvent( funcToTest: (action) =>
+                VersionHandler.InvokeStaticEventRemoveMethod(typeof(Greeter), "foo", action),
+                invokeEvent: Greeter.InvokeStaticEvent,
+                expectSuccess: false,
+                expectInvoked: false);
+
+        return true;
+    }
 }

source/VersionHandlerImpl/src/DialogWindow.cs

@@ -26,7 +26,6 @@ namespace Google {
 /// The dialog will not block the editor. When multiple dialogs are triggered, they will be queued
 /// and only be shown one at a time based on the triggering order.
 /// </summary>
-[Serializable]
 public class DialogWindow : EditorWindow {
     /// <summary>
     /// Option selected by the dialog.
@@ -62,9 +61,7 @@ public enum Option {
     /// All the data to render the content of the dialog and react to the user interaction.
     /// All the context should be serialable/deserialable so that all the context can be reloaded
     /// after Unity hot reloads.
-    /// TODO: Make Action serializable.
     /// </summary>
-    [Serializable]
     private class DialogContext {
         // Title of the dialog.
         internal string Title;
@@ -176,12 +173,14 @@ static private GUIStyle DefaultMessageStyle {
     static private GUIStyle defaultMessageStyle;
 
     // Context for this dialog window.
-    [SerializeField]
     private DialogContext dialogContext = new DialogContext();
 
     // The option selected by the user.
     private Option selectedOption = Option.SelectedNone;
 
+    // Whether this window is terminating due to Unity hot reload.
+    private bool terminating = false;
+
     /// <summary>
     /// Displays a non-blocking modal dialog with up to 3 options.
     /// </summary>
@@ -325,6 +324,19 @@ public static void Display(string title, string message, Option defaultOption,
     /// Render the dialog according to the context.
     /// </summary>
     void OnGUI() {
+        // Close the window if Option0String is empty.
+        // After Unity reload assemblies, the EditorWindow will remain open but all the content
+        // in the dialog will be cleared because dialogContext is not serializable. Therefore,
+        // close the dialog after assembly reload. Close in the next editor frame or it may
+        // generate error message like "OpenGL Context became invalid during rendering".
+        // This is for Unity 5.
+        if (String.IsNullOrEmpty(dialogContext.Option0String) && !terminating) {
+            terminating = true;
+            RunOnMainThread.Run(() => {
+                Close();
+            }, runNow: false);
+        }
+
         Rect rect = EditorGUILayout.BeginVertical();
 
         // Render the dialog message.
@@ -418,5 +430,26 @@ void OnDestroy() {
         // Complete the current dialog and display the next one if there is any in the queue.
         dialogJobQueue.Complete();
     }
-}  // class DialogWindow
+
+    // Function called when the dialog window is enabled.
+    void OnEnable() {
+        VersionHandler.RegisterBeforeAssemblyReloadEvent(OnBeforeAssemblyReload);
+    }
+
+    // Function called when the dialog window is disabled.
+    void OnDisable() {
+        VersionHandler.UnregisterBeforeAssemblyReloadEvent(OnBeforeAssemblyReload);
+    }
+
+    // Function called before assemblies will be reloaded.
+    private void OnBeforeAssemblyReload() {
+        // Close the window before assembly will be reloaded.
+        // After Unity reload assemblies, the EditorWindow will remain open but all the content
+        // in the dialog will be cleared because all Action are not serialiable.  Therefore,
+        // close the dialog before assembly reload.
+        // Note that this only works from Unity 2017 since any version below does not have
+        // the event API.
+        Close();
+    }
+}  // class NonBlockingDialog
 }  // namespace Google

source/VersionHandlerImpl/src/EditorMeasurement.cs

@@ -154,6 +154,9 @@ private set {
         }
     }
 
+    // Whether consent dialog has been displayed.
+    private bool ConsentRequesting = false;
+
     /// <summary>
     /// Project level cookie which enables reporting of unique projects.
     /// Empty string if analytics is disabled.
@@ -352,9 +355,10 @@ private static string GetAndCacheUnityRuntimePlatform() {
     /// Ask user to enable analytics.
     /// </summary>
     public void PromptToEnable(Action complete) {
-        if (ConsentRequested) {
+        if (ConsentRequesting || ConsentRequested) {
             complete();
         } else {
+            ConsentRequesting = true;
             displayDialog(
                 String.Format(EnableAnalytics, PluginName),
                 String.Format(RequestConsentMessage, PluginName),
@@ -369,6 +373,8 @@ public void PromptToEnable(Action complete) {
                             Enabled = false;
                             break;
                     }
+                    ConsentRequesting = false;
+                    ConsentRequested = true;
                     complete();
                 }, renderContent: dialog => {
                     GUILayout.Label(RequestConsentDataCollection,
@@ -406,7 +412,6 @@ public void PromptToEnable(Action complete) {
                     }
                     EditorGUILayout.Space();
                 });
-            ConsentRequested = true;
         }
     }
 

source/VersionHandlerImpl/src/VersionHandlerImpl.cs

@@ -2423,6 +2423,8 @@ private static void NotifyWhenCompliationComplete(bool forceNotification) {
                                                                   setCleanupFilesPending: false);
                             }, runNow: false);
                     }
+
+                    analytics.Report("enablemostrecentplugins", "Enable Most Recent Plugins");
                     NotifyUpdateCompleteMethods();
                 }
                 return true;
@@ -2824,7 +2826,6 @@ private static void UpdateVersionedAssetsOnMainThread(bool forceUpdate,
             ManifestReferences.FindAndReadManifests(allMetadataSet), allMetadataSet);
         if (metadataSet.EnableMostRecentPlugins(forceUpdate, obsoleteFiles.All)) {
             enabledEditorDlls.UnionWith(metadataSet.EnabledEditorDlls);
-            analytics.Report("enablemostrecentplugins", "Enable Most Recent Plugins");
             AssetDatabase.Refresh();
             Refreshing = true;
         }