Add support for VersionHandler to enable/disable files based on build target by renaming them.

Currently, we disable certain files per-platform by using PluginHandler, but this only works for libraries (.dll and the like), and does not work on some earlier versions of unity.  This change adds the ability for VersionHandler to disable files by modifying their file extension (from .zzz -> .zzz_DISABLED) based on the platform being targeted - using the same Asset Labels already being used for PluginHandler files.

Change-Id: I658ff0d37f68508cff6956beb8aa7084138c0fa4

Author: Ryan Meier

source/VersionHandlerImpl/src/SettingsDialog.cs

@@ -53,6 +53,11 @@ private class Settings {
         /// </summary>
         internal bool useProjectSettings;
 
+        /// <summary>
+        /// Whether files can be disabled by renaming them.
+        /// </summary>
+        internal bool renameToDisableFilesEnabled;
+
         /// <summary>
         /// Load settings into the dialog.
         /// </summary>
@@ -62,6 +67,7 @@ internal Settings() {
             renameToCanonicalFilenames = VersionHandlerImpl.RenameToCanonicalFilenames;
             verboseLoggingEnabled = VersionHandlerImpl.VerboseLoggingEnabled;
             useProjectSettings = VersionHandlerImpl.UseProjectSettings;
+            renameToDisableFilesEnabled = VersionHandlerImpl.RenameToDisableFilesEnabled;
         }
 
         /// <summary>
@@ -73,6 +79,9 @@ internal void Save() {
             VersionHandlerImpl.RenameToCanonicalFilenames = renameToCanonicalFilenames;
             VersionHandlerImpl.VerboseLoggingEnabled = verboseLoggingEnabled;
             VersionHandlerImpl.UseProjectSettings = useProjectSettings;
+            VersionHandlerImpl.RenameToDisableFilesEnabled = renameToDisableFilesEnabled;
+
+            VersionHandlerImpl.BuildTargetChecker.HandleSettingsChanged();
         }
     }
 
@@ -89,7 +98,7 @@ private void LoadSettings() {
     /// Setup the window's initial position and size.
     /// </summary>
     public void Initialize() {
-        minSize = new Vector2(300, 200);
+        minSize = new Vector2(300, 250);
         position = new Rect(UnityEngine.Screen.width / 3,
                             UnityEngine.Screen.height / 3,
                             minSize.x, minSize.y);
@@ -130,6 +139,12 @@ public void OnGUI() {
         settings.cleanUpPromptEnabled = EditorGUILayout.Toggle(settings.cleanUpPromptEnabled);
         GUILayout.EndHorizontal();
 
+        GUILayout.BeginHorizontal();
+        GUILayout.Label("Allow disabling files via renaming", EditorStyles.boldLabel);
+        settings.renameToDisableFilesEnabled =
+                                EditorGUILayout.Toggle(settings.renameToDisableFilesEnabled);
+        GUILayout.EndHorizontal();
+
         GUILayout.BeginHorizontal();
         GUILayout.Label("Verbose logging", EditorStyles.boldLabel);
         settings.verboseLoggingEnabled = EditorGUILayout.Toggle(settings.verboseLoggingEnabled);
@@ -140,6 +155,7 @@ public void OnGUI() {
         settings.useProjectSettings = EditorGUILayout.Toggle(settings.useProjectSettings);
         GUILayout.EndHorizontal();
 
+
         GUILayout.Space(10);
 
         if (GUILayout.Button("Reset to Defaults")) {

source/VersionHandlerImpl/src/VersionHandlerImpl.cs

@@ -99,6 +99,12 @@ private static Dictionary<string, BuildTarget>
         /// </summary>
         public static string ASSET_LABEL = "gvh";
 
+        /// <summary>
+        /// Label which flags whether an asset should be disabled by renaming the file
+        /// (instead of using the PluginManager).
+        /// </summary>
+        public static string ASSET_LABEL_RENAME_TO_DISABLE = "gvh_rename_to_disable";
+
         // Special build target name which enables all platforms / build targets.
         public static string BUILD_TARGET_NAME_ANY = "any";
 
@@ -267,6 +273,11 @@ public static string ScriptingRuntimeDotNetVersion {
         /// </summary>
         public bool isManifest = false;
 
+        /// <summary>
+        /// Set if this references an asset which is handled by PluginManager.
+        /// </summary>
+        public bool isHandledByPluginImporter = false;
+
         /// <summary>
         /// List of compatible .NET versions parsed from this asset.
         /// </summary>
@@ -306,6 +317,8 @@ public FileMetadata(string filename) {
                 foreach (string label in AssetDatabase.GetLabels(importer)) {
                     ParseLabel(label);
                 }
+
+                isHandledByPluginImporter = typeof(PluginImporter).IsInstanceOfType(importer);
             }
 
             // On Windows the AssetDatabase converts native path separators
@@ -515,6 +528,10 @@ public void UpdateAssetLabels() {
             }
             if (targets != null && targets.Length > 0) {
                 labels.Add(CreateLabel(TOKEN_TARGETS, targets));
+
+                if(!isHandledByPluginImporter) {
+                    labels.Add(ASSET_LABEL_RENAME_TO_DISABLE);
+                }
             }
             if (dotNetTargets != null && dotNetTargets.Length > 0) {
                 labels.Add(CreateLabel(TOKEN_DOTNET_TARGETS, dotNetTargets));
@@ -1429,12 +1446,15 @@ private string LibraryPrefix {
         "Google.VersionHandler.RenameToCanonicalFilenames";
     private const string PREFERENCE_VERBOSE_LOGGING_ENABLED =
         "Google.VersionHandler.VerboseLoggingEnabled";
+    private const string PREFERENCE_RENAME_TO_DISABLE_FILES_ENABLED =
+        "Google.VersionHandler.RenameToDisableFilesEnabled";
     // List of preference keys, used to restore default settings.
     private static string[] PREFERENCE_KEYS = new [] {
         PREFERENCE_ENABLED,
         PREFERENCE_CLEANUP_PROMPT_ENABLED,
         PREFERENCE_RENAME_TO_CANONICAL_FILENAMES,
-        PREFERENCE_VERBOSE_LOGGING_ENABLED
+        PREFERENCE_VERBOSE_LOGGING_ENABLED,
+        PREFERENCE_RENAME_TO_DISABLE_FILES_ENABLED
     };
 
     // Name of this plugin.
@@ -1466,6 +1486,7 @@ static VersionHandlerImpl() {
     static void UpdateVersionedAssetsOnUpdate() {
         UpdateVersionedAssets();
         NotifyWhenCompliationComplete(false);
+        UpdateAssetsWithBuildTargets(EditorUserBuildSettings.activeBuildTarget);
     }
 
     /// <summary>
@@ -1606,6 +1627,16 @@ public static bool VerboseLoggingEnabled {
         set { settings.SetBool(PREFERENCE_VERBOSE_LOGGING_ENABLED, value); }
     }
 
+    /// <summary>
+    /// Enable / disable verbose logging.
+    /// </summary>
+    public static bool RenameToDisableFilesEnabled {
+        get {
+            return settings.GetBool(PREFERENCE_RENAME_TO_DISABLE_FILES_ENABLED, defaultValue: true);
+        }
+        set { settings.SetBool(PREFERENCE_RENAME_TO_DISABLE_FILES_ENABLED, value); }
+    }
+
     /// <summary>
     /// Set the methods to call when VersionHandler completes an update.
     /// Each string in the specified list should have the format
@@ -1747,6 +1778,8 @@ public static void UpdateVersionedAssets(bool forceUpdate = false) {
         // If this module is disabled do nothing.
         if (!forceUpdate && !Enabled) return;
 
+        UpdateAssetsWithBuildTargets(EditorUserBuildSettings.activeBuildTarget);
+
         var metadataSet = FileMetadataSet.ParseFromFilenames(FindAllAssets());
         // Rename linux libraries, if any are being tracked.
         var linuxLibraries = new LinuxLibraryRenamer(metadataSet);
@@ -1825,6 +1858,70 @@ public static void UpdateVersionedAssets(bool forceUpdate = false) {
         }
     }
 
+    /// <summary>
+    /// Go through all files with build targets that need to be enabled/disabled by renaming
+    /// (can't be handled through PluginHandler) and enable/disable them based on the whether they
+    /// should build on currentBuildTarget.
+    /// </summary>
+    /// <param name="currentBuildTarget">
+    /// The BuildTarget to use to determine which files should be enabled/disabled.
+    /// </param>
+    public static void UpdateAssetsWithBuildTargets(BuildTarget currentBuildTarget) {
+        string[] assets = SearchAssetDatabase(
+                            assetsFilter: "l:" + FileMetadata.ASSET_LABEL_RENAME_TO_DISABLE);
+
+        var metadataSet = FileMetadataSet.ParseFromFilenames(assets);
+        foreach (var versionPair in metadataSet.Values) {
+            // Disable all but the most recent version of the file.
+            // Enable / disable most recent version based on whether its targets contain
+            // the currently selected build target.
+            foreach (var versionData in versionPair.Values) {
+                bool enabled = false;
+                if (versionData == versionPair.MostRecentVersion) {
+                    if (versionData.GetBuildTargetsSpecified()) {
+                        var buildTargets = versionData.GetBuildTargets();
+                        enabled = buildTargets.Contains(currentBuildTarget);
+                    } else {
+                        enabled = true;
+                    }
+                }
+
+                SetFileEnabledByRename(versionData, enabled);
+            }
+        }
+
+    }
+
+    /// <summary>
+    /// Enable or disable a file by renaming it (changing its extension to/from .xxx_DISABLED).
+    /// </summary>
+    /// <param name="metadata"> The metadata for the file which should be changed. </param>
+    /// <param name="enabled"> The new state of the file. </param>
+    private static void SetFileEnabledByRename(FileMetadata metadata, bool enabled) {
+        if (!RenameToDisableFilesEnabled)
+            return;
+
+        string disableToken = "_DISABLED";
+
+        var filename = metadata.filename;
+        var newFilename = filename;
+        if (enabled && filename.EndsWith(disableToken)) {
+            int tokenIndex = filename.LastIndexOf(disableToken);
+            if (tokenIndex > 0) {
+                newFilename = filename.Substring(0, tokenIndex);
+            }
+        } else if (!enabled && !filename.EndsWith(disableToken)) {
+            newFilename = filename + disableToken;
+        }
+
+        if (filename == newFilename || newFilename == "") {
+            return;
+        }
+
+        Log("Renaming file " + filename + " to " + newFilename, verbose: true);
+        AssetDatabase.MoveAsset(filename, newFilename);
+    }
+
     // Returns the major/minor version of the unity environment we are running in
     // as a float so it can be compared numerically.
     public static float GetUnityVersionMajorMinor() {
@@ -1878,6 +1975,52 @@ internal static string[] OnWillSaveAssets(string[] paths) {
             return paths;
         }
     }
+
+    /// <summary>
+    /// Update assets when BuildTarget changes.
+    /// </summary>
+    [InitializeOnLoad]
+    internal class BuildTargetChecker {
+        private static BuildTarget? lastKnownBuildTarget = null;
+        private static int ticksSinceLastCheck = 0;
+        private static int ticksBetweenChecks = 60;
+
+
+        static BuildTargetChecker() {
+            HandleSettingsChanged();
+        }
+
+        public static void HandleSettingsChanged() {
+            RunOnMainThread.OnUpdate -= CheckBuildTarget;
+            if (Enabled && RenameToDisableFilesEnabled) {
+                RunOnMainThread.OnUpdate += CheckBuildTarget;
+            }
+        }
+
+        private static void CheckBuildTarget() {
+            ticksSinceLastCheck++;
+            if (ticksSinceLastCheck < ticksBetweenChecks) {
+                return;
+            }
+
+            if (!Enabled || !RenameToDisableFilesEnabled) {
+                RunOnMainThread.OnUpdate -= CheckBuildTarget;
+            }
+
+            var newBuildTarget = EditorUserBuildSettings.activeBuildTarget;
+            if (lastKnownBuildTarget == null || newBuildTarget != lastKnownBuildTarget) {
+                lastKnownBuildTarget = newBuildTarget;
+                HandleBuildTargetChanged(newBuildTarget);
+            }
+
+            ticksSinceLastCheck = 0;
+        }
+
+        private static void HandleBuildTargetChanged(BuildTarget newBuildTarget) {
+            UpdateAssetsWithBuildTargets(newBuildTarget);
+        }
+
+    }
 }
 
 } // namespace Google