private static void SetPropertyByName <T>(string propertyName, T value) { PropertyInfo propertyByName = VersionHandler.GetPropertyByName(propertyName); if (propertyByName == null) { return; } propertyByName.SetValue(null, value, null); }
private static T GetPropertyByName <T>(string propertyName, T defaultValue) { PropertyInfo propertyByName = VersionHandler.GetPropertyByName(propertyName); if (propertyByName == null) { return(defaultValue); } return((T)((object)propertyByName.GetValue(null, null))); }
/// <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); }
public static void UpdateVersionedAssets(bool forceUpdate = false) { string methodName = "UpdateVersionedAssets"; Dictionary <string, object> namedArgs = new Dictionary <string, object> { { "forceUpdate", forceUpdate } }; VersionHandler.InvokeImplMethod(methodName, null, namedArgs, true); }
public static string[] SearchAssetDatabase(string assetsFilter = null, VersionHandler.FilenameFilter filter = null) { return(VersionHandler.StringArrayFromObject(VersionHandler.InvokeImplMethod("SearchAssetDatabase", null, new Dictionary <string, object> { { "assetsFilter", assetsFilter }, { "filter", filter } }, false))); }
/// <summary> /// Checks out a file should Version Control be active and valid. /// </summary> /// <param name="path">Path to the file that needs checking out.</param> /// <param name="logger">Logger, used to log any error messages.</param> /// <returns>False should the checkout fail, otherwise true.</returns> public static bool CheckoutFile(string path, Logger logger) { try { if (UnityEditor.VersionControl.Provider.enabled && UnityEditor.VersionControl.Provider.isActive && (!UnityEditor.VersionControl.Provider.requiresNetwork || UnityEditor.VersionControl.Provider.onlineState == UnityEditor.VersionControl.OnlineState.Online)) { // Some versions of Unity seem to have bug to convert "string path" to // "AssetList assets" (See #359). Generate it in advance as a workaround. var assetList = new UnityEditor.VersionControl.AssetList(); assetList.Add(new UnityEditor.VersionControl.Asset(path)); // Unity 2019.1+ broke backwards compatibility of Checkout() by adding an // optional argument to the method so we dynamically invoke the method to add // the optional // argument for the Unity 2019.1+ overload at runtime. var task = (UnityEditor.VersionControl.Task)VersionHandler.InvokeStaticMethod( typeof(UnityEditor.VersionControl.Provider), "Checkout", new object[] { assetList, UnityEditor.VersionControl.CheckoutMode.Exact }, namedArgs: null); task.Wait(); if (!task.success) { var errorMessage = new List <string>(); errorMessage.Add(String.Format("Failed to checkout {0}.", path)); if (task.messages != null) { foreach (var message in task.messages) { if (message != null) { errorMessage.Add(message.message); } } } logger.Log(String.Join("\n", errorMessage.ToArray()), level: LogLevel.Warning); return(false); } } return(true); } catch (Exception ex) { logger.Log(String.Format("Failed to checkout {0} ({1}.", path, ex), level: LogLevel.Warning); return(false); } }
private static object InvokeImplMethod(string methodName, object[] args = null, Dictionary <string, object> namedArgs = null, bool schedule = false) { Type bootStrappedImpl = VersionHandler.BootStrappedImpl; if (bootStrappedImpl == null) { if (VersionHandler.BootStrapping && schedule) { VersionHandler.AddToBootStrappingFile(new List <string> { methodName }); } return(null); } return(VersionHandler.InvokeStaticMethod(bootStrappedImpl, methodName, args, namedArgs)); }
public static float GetUnityVersionMajorMinor() { if (VersionHandler.unityVersionMajorMinor > 0f) { return(VersionHandler.unityVersionMajorMinor); } float result; try { object obj = VersionHandler.InvokeImplMethod("GetUnityVersionMajorMinor", null, null, false); VersionHandler.unityVersionMajorMinor = (float)obj; result = VersionHandler.unityVersionMajorMinor; } catch (Exception) { result = 0f; } return(result); }
// Function called when the dialog window is enabled. void OnEnable() { VersionHandler.RegisterBeforeAssemblyReloadEvent(OnBeforeAssemblyReload); }
public static object InvokeStaticMethod(Type type, string methodName, object[] args, Dictionary <string, object> namedArgs = null) { return(VersionHandler.InvokeMethod(type, null, methodName, args, namedArgs)); }
public static object InvokeInstanceMethod(object objectInstance, string methodName, object[] args, Dictionary <string, object> namedArgs = null) { return(VersionHandler.InvokeMethod(objectInstance.GetType(), objectInstance, methodName, args, namedArgs)); }
public static string[] FindAllAssets() { return(VersionHandler.StringArrayFromObject(VersionHandler.InvokeImplMethod("FindAllAssets", null, null, false))); }
public static void UpdateNow() { VersionHandler.InvokeImplMethod("UpdateNow", null, null, true); }
public static void ShowSettings() { VersionHandler.InvokeImplMethod("ShowSettings", null, null, false); }
// Function called when the dialog window is disabled. void OnDisable() { VersionHandler.UnregisterBeforeAssemblyReloadEvent(OnBeforeAssemblyReload); }
/// <summary> /// Enable the latest VersionHandler DLL if it's not already loaded. /// </summary> private static void BootStrap() { var bootStrapping = BootStrapping; var implAvailable = Impl != null; // If the VersionHandler assembly is already loaded or we're still bootstrapping we have // nothing to do. if (bootStrapping) { BootStrapping = !implAvailable; return; } EditorApplication.update -= BootStrap; if (implAvailable) { return; } var assemblies = new List <Match>(); foreach (string assetGuid in AssetDatabase.FindAssets("l:gvh")) { string filename = AssetDatabase.GUIDToAssetPath(assetGuid); var match = VERSION_HANDLER_FILENAME_RE.Match(filename); if (match.Success) { assemblies.Add(match); } } if (assemblies.Count == 0) { UnityEngine.Debug.LogWarning(String.Format("No {0} DLL found to bootstrap", VERSION_HANDLER_ASSEMBLY_NAME)); return; } // Sort assembly paths by version number. string mostRecentAssembly = null; var mostRecentVersionNumber = -1; foreach (var match in assemblies) { var filename = match.Groups[0].Value; var version = match.Groups[2].Value; // Convert a multi-component version number to a string. var components = version.Split(new [] { '.' }); Array.Reverse(components); var versionNumber = 0; var componentMultiplier = 1000; var currentComponentMultiplier = 1; foreach (var component in components) { try { versionNumber += Int32.Parse(component) * currentComponentMultiplier; } catch (FormatException) { // Ignore the component. } currentComponentMultiplier *= componentMultiplier; } if (versionNumber > mostRecentVersionNumber) { mostRecentVersionNumber = versionNumber; mostRecentAssembly = filename; } } if (String.IsNullOrEmpty(mostRecentAssembly)) { UnityEngine.Debug.LogWarning(String.Format("Failed to get the most recent {0} DLL. " + "Unable to bootstrap.", VERSION_HANDLER_ASSEMBLY_NAME)); return; } BootStrapping = true; if (VersionHandler.FindClass("UnityEditor", "UnityEditor.PluginImporter") != null) { EnableEditorPlugin(mostRecentAssembly); } else { ReimportPlugin(mostRecentAssembly); } }
private static void BootStrap() { bool bootStrapping = VersionHandler.BootStrapping; bool flag = VersionHandler.Impl != null; if (bootStrapping) { VersionHandler.BootStrapping = !flag; return; } Delegate arg_44_0 = EditorApplication.update; if (VersionHandler.callbackFunction2 == null) { VersionHandler.callbackFunction2 = new EditorApplication.CallbackFunction(VersionHandler.BootStrap); } EditorApplication.update = (EditorApplication.CallbackFunction)Delegate.Remove(arg_44_0, VersionHandler.callbackFunction2); if (flag) { return; } List <Match> list = new List <Match>(); string[] array = AssetDatabase.FindAssets("l:gvh"); for (int i = 0; i < array.Length; i++) { string guid = array[i]; string input = AssetDatabase.GUIDToAssetPath(guid); Match match = VersionHandler.VERSION_HANDLER_FILENAME_RE.Match(input); if (match.Success) { list.Add(match); } } if (list.Count == 0) { Debug.LogWarning(string.Format("No {0} DLL found to bootstrap", "Google.VersionHandlerImpl")); return; } string text = null; int num = -1; foreach (Match current in list) { string value = current.Groups[0].Value; string value2 = current.Groups[2].Value; string[] array2 = value2.Split(new char[] { '.' }); Array.Reverse(array2); int num2 = 0; int num3 = 1000; int num4 = 1; string[] array3 = array2; for (int j = 0; j < array3.Length; j++) { string s = array3[j]; try { num2 += int.Parse(s) * num4; } catch (FormatException) { } num4 *= num3; } if (num2 > num) { num = num2; text = value; } } if (string.IsNullOrEmpty(text)) { Debug.LogWarning(string.Format("Failed to get the most recent {0} DLL. Unable to bootstrap.", "Google.VersionHandlerImpl")); return; } VersionHandler.BootStrapping = true; if (VersionHandler.FindClass("UnityEditor", "UnityEditor.PluginImporter") != null) { VersionHandler.EnableEditorPlugin(text); } else { VersionHandler.ReimportPlugin(text); } }