initial commit

Library/PackageCache/com.unity.xr.management@4.2.1/Editor/Legacy/XRLegacyUninstaller.cs

@@ -0,0 +1,218 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+using UnityEditor;
+using UnityEditor.PackageManager;
+using UnityEditor.PackageManager.Requests;
+using UnityEditor.XR.Management;
+
+using UnityEngine;
+using UnityEngine.XR;
+using UnityEngine.XR.Management;
+
+
+namespace UnityEditor.XR.Management.Legacy
+{
+
+    [InitializeOnLoad]
+    class XRLegacyUninstaller
+    {
+        private static List<string> k_PackagesToBeRemoved = new List<string>(){
+            "com.unity.xr.googlevr.android",
+            "com.unity.xr.googlevr.ios",
+            "com.unity.xr.oculus.android",
+            "com.unity.xr.oculus.standalone",
+            "com.unity.xr.openvr.standalone",
+            "com.unity.xr.windowsmr.metro",
+        };
+
+
+        [Serializable]
+        struct PackageRemovalRequest
+        {
+            [SerializeField]
+            public string packageId;
+            [SerializeField]
+            public bool shouldCheckForInstallation;
+        }
+
+        [Serializable]
+        struct PackageRemovalOperation
+        {
+            [SerializeField]
+            public string packageId;
+
+            [SerializeField]
+            public RemoveRequest packageRemoveRequest;
+            [SerializeField]
+            public bool shouldCheckForInstallation;
+        }
+
+        [Serializable]
+        struct LegacyPackageListRequest
+        {
+            [SerializeField]
+            public ListRequest packageListRequest;
+        }
+
+
+        private static readonly string k_PackageToRemoveQueue = "Remove Package Queue";
+        private static EditorWorkQueue<PackageRemovalOperation> s_PackageRemovelQueue => EditorWorkQueue<PackageRemovalOperation>.Instance;
+        private static bool hasPackageBeingRemoved => s_PackageRemovelQueue.HasWorkItems;
+
+        private static readonly string k_WaitingToRemoveQueue = "Waiting Remove Queue";
+        private static EditorWorkQueue<PackageRemovalRequest> s_PackagesToRemoveQueue => EditorWorkQueue<PackageRemovalRequest>.Instance;
+        private static bool hasPackagesToRemove => s_PackagesToRemoveQueue.HasWorkItems;
+
+        private static readonly string k_LocalPackageListingQueryQueue = "Local Package List";
+        private static EditorWorkQueue<LegacyPackageListRequest> s_PackageListQueue => EditorWorkQueue<LegacyPackageListRequest>.Instance;
+        private static bool hasActivePackageListQuery => EditorWorkQueueBase.SessionStateHasStoredData(k_LocalPackageListingQueryQueue);
+
+
+        internal static bool IsPackageInstalled(string package)
+        {
+            return File.Exists($"Packages/{package}/package.json");
+        }
+
+        static XRLegacyUninstaller()
+        {
+            s_PackageRemovelQueue.QueueName = k_PackageToRemoveQueue;
+            s_PackageRemovelQueue.ProcessItemCallback += (PackageRemovalOperation prr) =>
+            {
+
+                if (prr.packageRemoveRequest == null || String.IsNullOrEmpty(prr.packageRemoveRequest.PackageIdOrName))
+                {
+                    return;
+                }
+
+                if (prr.packageRemoveRequest.Status == StatusCode.Failure)
+                {
+                    return;
+                }
+
+                if (!prr.packageRemoveRequest.IsCompleted || (prr.shouldCheckForInstallation && IsPackageInstalled(prr.packageId)))
+                {
+                    s_PackageRemovelQueue.QueueWorkItem(prr);
+                    return;
+                }
+
+
+            };
+            if (s_PackageRemovelQueue.HasWorkItems) s_PackageRemovelQueue.StartQueue();
+
+            s_PackagesToRemoveQueue.QueueName = k_WaitingToRemoveQueue;
+            s_PackagesToRemoveQueue.ProcessItemCallback += (PackageRemovalRequest prr) =>
+            {
+                if (s_PackageRemovelQueue.HasWorkItems)
+                {
+                    s_PackagesToRemoveQueue.QueueWorkItem(prr);
+                    return;
+                }
+
+                if (!String.IsNullOrEmpty(prr.packageId) && IsPackageInstalled(prr.packageId))
+                {
+                    PackageRemovalOperation pro = new PackageRemovalOperation { packageId = prr.packageId, packageRemoveRequest = PackageManager.Client.Remove(prr.packageId), shouldCheckForInstallation=prr.shouldCheckForInstallation };
+                    s_PackageRemovelQueue.QueueWorkItem(pro);
+                }
+            };
+            if (s_PackagesToRemoveQueue.HasWorkItems) s_PackagesToRemoveQueue.StartQueue();
+
+            var packageSettings = XRPackageInitializationSettings.Instance;
+            if (packageSettings.HasSettings("ShouldQueryLegacyPackageRemoval"))
+            {
+                return;
+            }
+
+            if (!packageSettings.HasSettings("RemoveLegacyInputHelpersForReload"))
+            {
+                PackageRemovalRequest lihremreq = new PackageRemovalRequest();
+                lihremreq.packageId = "com.unity.xr.legacyinputhelpers";
+                lihremreq.shouldCheckForInstallation = false;
+                s_PackagesToRemoveQueue.QueueWorkItem(lihremreq);
+                packageSettings.AddSettings("RemoveLegacyInputHelpersForReload");
+                packageSettings.SaveSettings();
+            }
+
+            s_PackageListQueue.QueueName = k_LocalPackageListingQueryQueue;
+            s_PackageListQueue.ProcessItemCallback += (LegacyPackageListRequest plr) => {
+                if (plr.packageListRequest == null)
+                    return;
+
+                if (!plr.packageListRequest.IsCompleted)
+                {
+                    s_PackageListQueue.QueueWorkItem(plr);
+                }
+                else
+                {
+                    if (plr.packageListRequest.Status == PackageManager.StatusCode.Success)
+                    {
+                        List<string> packageIdsToRemove = new List<string>();
+                        string removeRequestText = $"{XRConstants.k_XRPluginManagement} has detected that this project is using built in VR. Built in VR is incompatible with the new XR Plug-in system and any built in packages should be removed.\nDo you want {XRConstants.k_XRPluginManagement} to remove the following packages for you?\n\n";
+                        foreach (var package in plr.packageListRequest.Result)
+                        {
+                            if (k_PackagesToBeRemoved.Contains(package.name))
+                            {
+                                packageIdsToRemove.Add(package.name);
+                                removeRequestText += $"{package.displayName}\n";
+                            }
+                        }
+
+                        removeRequestText += "\nChoosing to cancel will require manual removal of built-in integration packages through the Package Manger window.";
+
+                        if (packageIdsToRemove.Count > 0)
+                        {
+                            if (EditorUtility.DisplayDialog("Built in VR Detected", removeRequestText, "Ok", "Cancel"))
+                            {
+                                foreach (string packageId in packageIdsToRemove)
+                                {
+                                    PackageRemovalRequest remreq = new PackageRemovalRequest();
+                                    remreq.packageId = packageId;
+                                    remreq.shouldCheckForInstallation = true;
+                                    s_PackagesToRemoveQueue.QueueWorkItem(remreq);
+                                }
+                            }
+
+                            var packSettings = XRPackageInitializationSettings.Instance;
+                            packSettings.AddSettings("ShouldQueryLegacyPackageRemoval");
+                            packSettings.SaveSettings();
+                        }
+
+#if !UNITY_2020_2_OR_NEWER
+                        bool virtualRealityEnabled = false;
+                        foreach (var buildTargetGroup in (BuildTargetGroup[])Enum.GetValues(typeof(BuildTargetGroup)))
+                        {
+#pragma warning disable CS0618
+                            virtualRealityEnabled |= PlayerSettings.GetVirtualRealitySupported(buildTargetGroup);
+#pragma warning restore CS0618
+                        }
+
+                        if (virtualRealityEnabled)
+                        {
+                            if (EditorUtility.DisplayDialog("Built in VR Enabled", $"{XRConstants.k_XRPluginManagement} has detected that Built-In VR is enabled. We must disable Built-In VR prior to using {XRConstants.k_XRPluginManagement}.", "Ok"))
+                            {
+                                foreach (var buildTargetGroup in (BuildTargetGroup[])Enum.GetValues(typeof(BuildTargetGroup)))
+                                {
+#pragma warning disable CS0618
+                                    if (PlayerSettings.GetVirtualRealitySupported(buildTargetGroup))
+                                    {
+                                        PlayerSettings.SetVirtualRealitySupported(buildTargetGroup, false);
+                                        UnityEditorInternal.VR.VREditor.SetVREnabledDevicesOnTargetGroup(buildTargetGroup, new string[]{});
+                                    }
+#pragma warning restore CS0618
+                                }
+                            }
+                        }
+#endif //!UNITY_2020_2_OR_NEWER
+}
+                }
+            };
+
+            LegacyPackageListRequest req = new LegacyPackageListRequest();
+            req.packageListRequest = PackageManager.Client.List(true, true);
+            s_PackageListQueue.QueueWorkItem(req);
+        }
+
+    }
+}
+

Library/PackageCache/com.unity.xr.management@4.2.1/Editor/Legacy/XRLegacyUninstaller.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3ffc80ed5a6b6e74499a45b59a238640
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: