Usages renaming commit

josepmariapujol-unity · josepmariapujol-unity · commit d14924b385b8 · 2026-01-09T10:26:08.000+01:00
diff --git a/Assets/QA/Tests/XRDeviceActions/_SharedScripts/Handedness.cs b/Assets/QA/Tests/XRDeviceActions/_SharedScripts/Handedness.cs
@@ -12,8 +12,8 @@ public void Update()
     {
         var handedness = "";
 
-        var leftHand = InputSystem.GetDevice<XRController>(CommonUsages.LeftHand);
-        var rightHand = InputSystem.GetDevice<XRController>(CommonUsages.RightHand);
+        var leftHand = InputSystem.GetDevice<XRController>(Usages.LeftHand);
+        var rightHand = InputSystem.GetDevice<XRController>(Usages.RightHand);
 
         if (leftHand != null)
             handedness += "Left ";
diff --git a/Assets/Samples/CustomDeviceUsages/CustomDeviceUsages.cs b/Assets/Samples/CustomDeviceUsages/CustomDeviceUsages.cs
@@ -52,14 +52,14 @@ private static void Initialize()
         // The layout override is just a fragment of layout information
         // in JSON format.
         //
-        // The key property here is "commonUsages" which tells the system
+        // The key property here is "usages" which tells the system
         // that "Player1" and "Player2" are possible usages applied to devices
         // using the given layout ("Gamepad" in our case).
         InputSystem.RegisterLayoutOverride(@"
             {
                 ""name"" : ""GamepadPlayerUsageTags"",
                 ""extend"" : ""Gamepad"",
-                ""commonUsages"" : [
+                ""usages"" : [
                     ""Player1"", ""Player2""
                 ]
             }
diff --git a/Assets/Tests/InputSystem/CoreTests_Actions_Rebinding.cs b/Assets/Tests/InputSystem/CoreTests_Actions_Rebinding.cs
@@ -776,7 +776,7 @@ public void Actions_InteractiveRebinding_IfDeviceHasUsages_UsagesAreAppliedToOve
         var action = new InputAction(binding: "<Gamepad>/buttonSouth");
 
         var rightHand = InputSystem.AddDevice<Gamepad>();
-        InputSystem.SetDeviceUsage(rightHand, CommonUsages.RightHand);
+        InputSystem.SetDeviceUsage(rightHand, Usages.RightHand);
 
         using (var rebind = new InputActionRebindingExtensions.RebindingOperation().WithAction(action).Start())
         {
@@ -1122,8 +1122,8 @@ public void Actions_InteractiveRebinding_IfDeviceHasMultipleUsages_UsagesAreAppl
 
         var rightHandVertical = InputSystem.AddDevice<Gamepad>();
 
-        InputSystem.SetDeviceUsage(rightHandVertical, CommonUsages.RightHand);
-        InputSystem.AddDeviceUsage(rightHandVertical, CommonUsages.Vertical);
+        InputSystem.SetDeviceUsage(rightHandVertical, Usages.RightHand);
+        InputSystem.AddDeviceUsage(rightHandVertical, Usages.Vertical);
 
         using (var rebind = new InputActionRebindingExtensions.RebindingOperation().WithAction(action).Start())
         {
diff --git a/Assets/Tests/InputSystem/CoreTests_Devices.cs b/Assets/Tests/InputSystem/CoreTests_Devices.cs
@@ -210,7 +210,7 @@ public void Devices_ChangingUsageOfDevice_SendsDeviceChangeNotification()
             receivedDeviceChange = c;
         };
 
-        InputSystem.SetDeviceUsage(device, CommonUsages.LeftHand);
+        InputSystem.SetDeviceUsage(device, Usages.LeftHand);
 
         Assert.That(receivedDevice, Is.SameAs(device));
         Assert.That(receivedDeviceChange, Is.EqualTo(InputDeviceChange.UsageChanged));
@@ -223,7 +223,7 @@ public void Devices_CanFindDeviceByUsage()
         InputSystem.AddDevice<Gamepad>();
         var device = InputSystem.AddDevice<Keyboard>();
 
-        InputSystem.SetDeviceUsage(device, CommonUsages.LeftHand);
+        InputSystem.SetDeviceUsage(device, Usages.LeftHand);
 
         using (var controls = InputSystem.FindControls("/{LeftHand}"))
         {
@@ -292,8 +292,8 @@ public void Devices_CanFindDeviceByMultipleUsages()
         InputSystem.AddDevice<Gamepad>();
         var device = InputSystem.AddDevice<Gamepad>();
 
-        InputSystem.SetDeviceUsage(device, CommonUsages.LeftHand);
-        InputSystem.AddDeviceUsage(device, CommonUsages.Vertical);
+        InputSystem.SetDeviceUsage(device, Usages.LeftHand);
+        InputSystem.AddDeviceUsage(device, Usages.Vertical);
 
         // Device should be found even if the one of the usages is specified
         using (var controls = InputSystem.FindControls("/{LeftHand}"))
@@ -328,10 +328,10 @@ public void Devices_CanFindDeviceByMultipleUsages()
     public void Devices_CanFindDeviceByUsageAndLayout()
     {
         var gamepad = InputSystem.AddDevice<Gamepad>();
-        InputSystem.SetDeviceUsage(gamepad, CommonUsages.LeftHand);
+        InputSystem.SetDeviceUsage(gamepad, Usages.LeftHand);
 
         var keyboard = InputSystem.AddDevice<Keyboard>();
-        InputSystem.SetDeviceUsage(keyboard, CommonUsages.LeftHand);
+        InputSystem.SetDeviceUsage(keyboard, Usages.LeftHand);
 
         using (var controls = InputSystem.FindControls("/<Keyboard>{LeftHand}"))
         {
@@ -925,11 +925,11 @@ public void Devices_CanLookUpDeviceByTypeAndUsage()
         var rightHand = InputSystem.AddDevice<Gamepad>();
         InputSystem.AddDevice<Gamepad>(); // Noise.
 
-        InputSystem.SetDeviceUsage(leftHand, CommonUsages.LeftHand);
-        InputSystem.SetDeviceUsage(rightHand, CommonUsages.RightHand);
+        InputSystem.SetDeviceUsage(leftHand, Usages.LeftHand);
+        InputSystem.SetDeviceUsage(rightHand, Usages.RightHand);
 
-        Assert.That(InputSystem.GetDevice<Gamepad>(CommonUsages.LeftHand), Is.SameAs(leftHand));
-        Assert.That(InputSystem.GetDevice<Gamepad>(CommonUsages.RightHand), Is.SameAs(rightHand));
+        Assert.That(InputSystem.GetDevice<Gamepad>(Usages.LeftHand), Is.SameAs(leftHand));
+        Assert.That(InputSystem.GetDevice<Gamepad>(Usages.RightHand), Is.SameAs(rightHand));
     }
 
     [Test]
diff --git a/Assets/Tests/InputSystem/CoreTests_Editor.cs b/Assets/Tests/InputSystem/CoreTests_Editor.cs
@@ -217,14 +217,14 @@ public void Editor_DomainReload_CanRestoreDevicesBuiltWithDynamicallyGeneratedLa
     public void Editor_DomainReload_PreservesUsagesOnDevices()
     {
         var device = InputSystem.AddDevice<Gamepad>();
-        InputSystem.SetDeviceUsage(device, CommonUsages.LeftHand);
+        InputSystem.SetDeviceUsage(device, Usages.LeftHand);
 
         SimulateDomainReload();
 
         var newDevice = InputSystem.devices[0];
 
         Assert.That(newDevice.usages, Has.Count.EqualTo(1));
-        Assert.That(newDevice.usages, Has.Exactly(1).EqualTo(CommonUsages.LeftHand));
+        Assert.That(newDevice.usages, Has.Exactly(1).EqualTo(Usages.LeftHand));
     }
 
     // We have code that will automatically query the enabled state of devices on creation
diff --git a/Assets/Tests/InputSystem/CoreTests_Layouts.cs b/Assets/Tests/InputSystem/CoreTests_Layouts.cs
@@ -185,7 +185,7 @@ public void Layouts_CanSetUsagesThroughControlAttribute()
     {
         var gamepad = InputSystem.AddDevice<Gamepad>();
 
-        Assert.That(gamepad.leftStick.usages, Has.Exactly(1).EqualTo(CommonUsages.Primary2DMotion));
+        Assert.That(gamepad.leftStick.usages, Has.Exactly(1).EqualTo(Usages.Primary2DMotion));
     }
 
     [Test]
@@ -460,7 +460,7 @@ public void Layouts_CanSpecifyCommonUsagesForDevices()
             {
                 ""name"" : ""DerivedDevice"",
                 ""extend"" : ""BaseDevice"",
-                ""commonUsages"" : [ ""LeftToe"" ]
+                ""usages"" : [ ""LeftToe"" ]
             }
         ";
 
@@ -469,10 +469,10 @@ public void Layouts_CanSpecifyCommonUsagesForDevices()
 
         var layout = InputSystem.LoadLayout("DerivedDevice");
 
-        Assert.That(layout.commonUsages, Has.Count.EqualTo(3));
-        Assert.That(layout.commonUsages[0], Is.EqualTo(CommonUsages.LeftHand));
-        Assert.That(layout.commonUsages[1], Is.EqualTo(CommonUsages.RightHand));
-        Assert.That(layout.commonUsages[2], Is.EqualTo(new InternedString("LeftToe")));
+        Assert.That(layout.usages, Has.Count.EqualTo(3));
+        Assert.That(layout.usages[0], Is.EqualTo(Usages.LeftHand));
+        Assert.That(layout.usages[1], Is.EqualTo(Usages.RightHand));
+        Assert.That(layout.usages[2], Is.EqualTo(new InternedString("LeftToe")));
     }
 
     [Test]
@@ -1084,12 +1084,12 @@ public void Layouts_ApplyingOverride_DoesNotAlterExistingInheritanceHierarchy()
     [Category("Layouts")]
     public void Layouts_CanOverrideCommonUsagesOnExistingLayout()
     {
-        // Change all Gamepads to have the common usages "A", "B", and "C".
+        // Change all Gamepads to have the usages "A", "B", and "C".
         const string json = @"
             {
                 ""name"" : ""Overrides"",
                 ""extend"" : ""Gamepad"",
-                ""commonUsages"" : [ ""A"", ""B"", ""C"" ]
+                ""usages"" : [ ""A"", ""B"", ""C"" ]
             }
         ";
 
@@ -1098,10 +1098,10 @@ public void Layouts_CanOverrideCommonUsagesOnExistingLayout()
         var layout = InputSystem.LoadLayout("Gamepad");
 
         Assert.That(layout.appliedOverrides, Is.EquivalentTo(new[] {new InternedString("Overrides")}));
-        Assert.That(layout.commonUsages.Count, Is.EqualTo(3));
-        Assert.That(layout.commonUsages, Has.Exactly(1).EqualTo(new InternedString("A")));
-        Assert.That(layout.commonUsages, Has.Exactly(1).EqualTo(new InternedString("B")));
-        Assert.That(layout.commonUsages, Has.Exactly(1).EqualTo(new InternedString("C")));
+        Assert.That(layout.usages.Count, Is.EqualTo(3));
+        Assert.That(layout.usages, Has.Exactly(1).EqualTo(new InternedString("A")));
+        Assert.That(layout.usages, Has.Exactly(1).EqualTo(new InternedString("B")));
+        Assert.That(layout.usages, Has.Exactly(1).EqualTo(new InternedString("C")));
 
         // Applying the override should not have created a cycle.
         Assert.That(layout.baseLayouts, Does.Not.Contains(new InternedString("Gamepad")));
@@ -2743,37 +2743,37 @@ public void Layouts_CanConfigureDeviceUsages()
         Assert.That(gamepad.usages, Is.Empty);
 
         // Set "Vertical" as usage
-        InputSystem.SetDeviceUsage(gamepad, CommonUsages.Vertical);
-        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(CommonUsages.Vertical));
+        InputSystem.SetDeviceUsage(gamepad, Usages.Vertical);
+        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(Usages.Vertical));
 
         // Change usage with "Horizontal"
-        InputSystem.SetDeviceUsage(gamepad, CommonUsages.Horizontal);
-        Assert.That(gamepad.usages, Has.Exactly(0).EqualTo(CommonUsages.Vertical));
-        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(CommonUsages.Horizontal));
+        InputSystem.SetDeviceUsage(gamepad, Usages.Horizontal);
+        Assert.That(gamepad.usages, Has.Exactly(0).EqualTo(Usages.Vertical));
+        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(Usages.Horizontal));
 
 
         // Add "Vertical" to usages
-        InputSystem.AddDeviceUsage(gamepad, CommonUsages.Vertical);
-        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(CommonUsages.Vertical));
-        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(CommonUsages.Horizontal));
+        InputSystem.AddDeviceUsage(gamepad, Usages.Vertical);
+        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(Usages.Vertical));
+        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(Usages.Horizontal));
 
         // Set "Horizontal" as the only one usage
-        InputSystem.SetDeviceUsage(gamepad, CommonUsages.Horizontal);
-        Assert.That(gamepad.usages, Has.Exactly(0).EqualTo(CommonUsages.Vertical));
-        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(CommonUsages.Horizontal));
+        InputSystem.SetDeviceUsage(gamepad, Usages.Horizontal);
+        Assert.That(gamepad.usages, Has.Exactly(0).EqualTo(Usages.Vertical));
+        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(Usages.Horizontal));
 
         // Try to add "Horizontal" again
-        InputSystem.AddDeviceUsage(gamepad, CommonUsages.Horizontal);
-        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(CommonUsages.Horizontal));
+        InputSystem.AddDeviceUsage(gamepad, Usages.Horizontal);
+        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(Usages.Horizontal));
 
 
         // Remove the existed "Horizontal" usage from usages
-        InputSystem.AddDeviceUsage(gamepad, CommonUsages.Vertical);
-        InputSystem.RemoveDeviceUsage(gamepad, CommonUsages.Horizontal);
-        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(CommonUsages.Vertical));
-        Assert.That(gamepad.usages, Has.Exactly(0).EqualTo(CommonUsages.Horizontal));
+        InputSystem.AddDeviceUsage(gamepad, Usages.Vertical);
+        InputSystem.RemoveDeviceUsage(gamepad, Usages.Horizontal);
+        Assert.That(gamepad.usages, Has.Exactly(1).EqualTo(Usages.Vertical));
+        Assert.That(gamepad.usages, Has.Exactly(0).EqualTo(Usages.Horizontal));
 
-        InputSystem.RemoveDeviceUsage(gamepad, CommonUsages.Vertical);
+        InputSystem.RemoveDeviceUsage(gamepad, Usages.Vertical);
         Assert.That(gamepad.usages, Is.Empty);
     }
 
diff --git a/Assets/Tests/InputSystem/CoreTests_Remoting.cs b/Assets/Tests/InputSystem/CoreTests_Remoting.cs
@@ -159,15 +159,15 @@ public void Remote_RemovingDevice_WillRemoveItFromRemotes()
     public void Remote_DevicesWithExistingUsage_WillUpdateSendToRemote()
     {
         var gamepad = InputSystem.AddDevice<Gamepad>();
-        InputSystem.SetDeviceUsage(gamepad, CommonUsages.LeftHand);
-        InputSystem.AddDeviceUsage(gamepad, CommonUsages.RightHand);
+        InputSystem.SetDeviceUsage(gamepad, Usages.LeftHand);
+        InputSystem.AddDeviceUsage(gamepad, Usages.RightHand);
 
         using (var remote = new FakeRemote())
         {
             var remoteGamepad = (Gamepad)remote.remoteManager.devices[0];
             Assert.That(remoteGamepad.usages, Has.Count.EqualTo(2));
-            Assert.That(remoteGamepad.usages, Has.Exactly(1).EqualTo(CommonUsages.LeftHand));
-            Assert.That(remoteGamepad.usages, Has.Exactly(1).EqualTo(CommonUsages.RightHand));
+            Assert.That(remoteGamepad.usages, Has.Exactly(1).EqualTo(Usages.LeftHand));
+            Assert.That(remoteGamepad.usages, Has.Exactly(1).EqualTo(Usages.RightHand));
         }
     }
 
@@ -182,26 +182,26 @@ public void Remote_SettingUsageOnDevice_WillSendChangeToRemotes()
             Assert.That(remoteGamepad.usages, Has.Count.Zero);
 
             // Can Set
-            InputSystem.SetDeviceUsage(gamepad, CommonUsages.LeftHand);
+            InputSystem.SetDeviceUsage(gamepad, Usages.LeftHand);
             Assert.That(remoteGamepad.usages, Has.Count.EqualTo(1));
-            Assert.That(remoteGamepad.usages, Has.Exactly(1).EqualTo(CommonUsages.LeftHand));
+            Assert.That(remoteGamepad.usages, Has.Exactly(1).EqualTo(Usages.LeftHand));
 
             // Can Replace
-            InputSystem.SetDeviceUsage(gamepad, CommonUsages.RightHand);
+            InputSystem.SetDeviceUsage(gamepad, Usages.RightHand);
             Assert.That(remoteGamepad.usages, Has.Count.EqualTo(1));
-            Assert.That(remoteGamepad.usages, Has.Exactly(1).EqualTo(CommonUsages.RightHand));
+            Assert.That(remoteGamepad.usages, Has.Exactly(1).EqualTo(Usages.RightHand));
 
             //Can Clear
-            InputSystem.RemoveDeviceUsage(gamepad, CommonUsages.LeftHand);
-            InputSystem.RemoveDeviceUsage(gamepad, CommonUsages.RightHand);
+            InputSystem.RemoveDeviceUsage(gamepad, Usages.LeftHand);
+            InputSystem.RemoveDeviceUsage(gamepad, Usages.RightHand);
             Assert.That(remoteGamepad.usages, Has.Count.Zero);
 
             //Can Set Multiple
-            InputSystem.AddDeviceUsage(gamepad, CommonUsages.LeftHand);
-            InputSystem.AddDeviceUsage(gamepad, CommonUsages.RightHand);
+            InputSystem.AddDeviceUsage(gamepad, Usages.LeftHand);
+            InputSystem.AddDeviceUsage(gamepad, Usages.RightHand);
             Assert.That(remoteGamepad.usages, Has.Count.EqualTo(2));
-            Assert.That(remoteGamepad.usages, Has.Exactly(1).EqualTo(CommonUsages.LeftHand));
-            Assert.That(remoteGamepad.usages, Has.Exactly(1).EqualTo(CommonUsages.RightHand));
+            Assert.That(remoteGamepad.usages, Has.Exactly(1).EqualTo(Usages.LeftHand));
+            Assert.That(remoteGamepad.usages, Has.Exactly(1).EqualTo(Usages.RightHand));
         }
     }
 
diff --git a/Assets/Tests/InputSystem/Plugins/PlayerInputTests.cs b/Assets/Tests/InputSystem/Plugins/PlayerInputTests.cs
@@ -2556,7 +2556,7 @@ public void PlayerInput_WhenOverridingDeviceLayout_LostDeviceShouldBeResolvedAnd
             {
                 ""name"" : ""GamepadPlayerUsageTags"",
                 ""extend"" : ""Gamepad"",
-                ""commonUsages"" : [
+                ""usages"" : [
                     ""Player1"", ""Player2""
                 ]
             }
diff --git a/Assets/Tests/InputSystem/Plugins/XRTests.cs b/Assets/Tests/InputSystem/Plugins/XRTests.cs
@@ -15,7 +15,7 @@
 using UnityEngine.TestTools;
 using UnityEngine.XR;
 
-using Usages = UnityEngine.InputSystem.CommonUsages;
+using Usages = UnityEngine.InputSystem.Usages;
 
 using InputDeviceRole = UnityEngine.XR.InputDeviceRole;
 
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/InputControlScheme.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/InputControlScheme.cs
@@ -907,7 +907,7 @@ public void Dispose()
         /// <remarks>
         /// Note that device requirements may require specific controls to be present rather than only requiring
         /// the presence of a certain type of device. For example, a requirement with a <see cref="controlPath"/>
-        /// of "*/{PrimaryAction}" will be satisfied by any device that has a control marked as <see cref="CommonUsages.PrimaryAction"/>.
+        /// of "*/{PrimaryAction}" will be satisfied by any device that has a control marked as <see cref="Usages.PrimaryAction"/>.
         ///
         /// Requirements are ordered in a list and can combine with their previous requirement in either <see cref="isAND">
         /// AND</see> or in <see cref="isOR">OR</see> fashion. The default is for requirements to combine with AND.
diff --git a/Packages/com.unity.inputsystem/InputSystem/Controls/InputControlLayout.cs b/Packages/com.unity.inputsystem/InputSystem/Controls/InputControlLayout.cs
@@ -418,7 +418,7 @@ private enum Flags
 
         public IEnumerable<InternedString> appliedOverrides => m_AppliedOverrides;
 
-        public ReadOnlyArray<InternedString> commonUsages => new ReadOnlyArray<InternedString>(m_CommonUsages);
+        public ReadOnlyArray<InternedString> usages => new ReadOnlyArray<InternedString>(m_Usages);
 
         /// <summary>
         /// List of child controls defined for the layout.
@@ -997,7 +997,7 @@ public static InputControlLayout FromType(string name, Type type)
             };
 
             if (layoutAttribute?.usages != null)
-                layout.m_CommonUsages =
+                layout.m_Usages =
                     ArrayHelpers.Select(layoutAttribute.usages, x => new InternedString(x));
 
             return layout;
@@ -1027,7 +1027,7 @@ public static InputControlLayout FromJson(string json)
         internal bool? m_UpdateBeforeRender;
         internal InlinedArray<InternedString> m_BaseLayouts;
         private InlinedArray<InternedString> m_AppliedOverrides;
-        private InternedString[] m_CommonUsages;
+        private InternedString[] m_Usages;
         internal ControlItem[] m_Controls;
         internal string m_DisplayName;
         private string m_Description;
@@ -1368,7 +1368,7 @@ public void MergeLayout(InputControlLayout other)
                 m_StateFormat = other.m_StateFormat;
 
             // Combine common usages.
-            m_CommonUsages = ArrayHelpers.Merge(other.m_CommonUsages, m_CommonUsages);
+            m_Usages = ArrayHelpers.Merge(other.m_Usages, m_Usages);
 
             // Retain list of overrides.
             m_AppliedOverrides.Merge(other.m_AppliedOverrides);
@@ -1658,7 +1658,7 @@ public InputControlLayout ToLayout()
                     isGenericTypeOfDevice = isGenericTypeOfDevice,
                     hideInUI = hideInUI,
                     m_Variants = new InternedString(variant),
-                    m_CommonUsages = ArrayHelpers.Select(commonUsages, x => new InternedString(x)),
+                    m_Usages = ArrayHelpers.Select(usages, x => new InternedString(x)),
                 };
                 if (!string.IsNullOrEmpty(format))
                     layout.m_StateFormat = new FourCC(format);
@@ -1725,7 +1725,7 @@ public static LayoutJson FromLayout(InputControlLayout layout)
                     extend = layout.m_BaseLayouts.length == 1 ? layout.m_BaseLayouts[0].ToString() : null,
                     extendMultiple = layout.m_BaseLayouts.length > 1 ? layout.m_BaseLayouts.ToArray(x => x.ToString()) : null,
                     format = layout.stateFormat.ToString(),
-                    commonUsages = ArrayHelpers.Select(layout.m_CommonUsages, x => x.ToString()),
+                    usages = ArrayHelpers.Select(layout.m_Usages, x => x.ToString()),
                     controls = ControlItemJson.FromControlItems(layout.m_Controls),
                     beforeRender = layout.m_UpdateBeforeRender != null ? (layout.m_UpdateBeforeRender.Value ? "Update" : "Ignore") : null,
                 };
diff --git a/Packages/com.unity.inputsystem/InputSystem/Controls/Usages.cs b/Packages/com.unity.inputsystem/InputSystem/Controls/Usages.cs
diff --git a/Packages/com.unity.inputsystem/InputSystem/Devices/Joystick.cs b/Packages/com.unity.inputsystem/InputSystem/Devices/Joystick.cs
diff --git a/Packages/com.unity.inputsystem/InputSystem/Editor/ControlPicker/InputControlPickerDropdown.cs b/Packages/com.unity.inputsystem/InputSystem/Editor/ControlPicker/InputControlPickerDropdown.cs
diff --git a/Packages/com.unity.inputsystem/InputSystem/Editor/Debugger/InputDebuggerWindow.cs b/Packages/com.unity.inputsystem/InputSystem/Editor/Debugger/InputDebuggerWindow.cs
diff --git a/Packages/com.unity.inputsystem/InputSystem/InputSystem.cs b/Packages/com.unity.inputsystem/InputSystem/InputSystem.cs

Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,8 @@ public void Update()`
`12`	`12`	`{`
`13`	`13`	`var handedness = "";`
`14`	`14`
`15`		`- var leftHand = InputSystem.GetDevice<XRController>(CommonUsages.LeftHand);`
`16`		`- var rightHand = InputSystem.GetDevice<XRController>(CommonUsages.RightHand);`
	`15`	`+ var leftHand = InputSystem.GetDevice<XRController>(Usages.LeftHand);`
	`16`	`+ var rightHand = InputSystem.GetDevice<XRController>(Usages.RightHand);`
`17`	`17`
`18`	`18`	`if (leftHand != null)`
`19`	`19`	`handedness += "Left ";`
Original file line number	Diff line number	Diff line change
`@@ -52,14 +52,14 @@ private static void Initialize()`
`52`	`52`	`// The layout override is just a fragment of layout information`
`53`	`53`	`// in JSON format.`
`54`	`54`	`//`
`55`		`- // The key property here is "commonUsages" which tells the system`
	`55`	`+ // The key property here is "usages" which tells the system`
`56`	`56`	`// that "Player1" and "Player2" are possible usages applied to devices`
`57`	`57`	`// using the given layout ("Gamepad" in our case).`
`58`	`58`	`InputSystem.RegisterLayoutOverride(@"`
`59`	`59`	`{`
`60`	`60`	`""name"" : ""GamepadPlayerUsageTags"",`
`61`	`61`	`""extend"" : ""Gamepad"",`
`62`		`- ""commonUsages"" : [`
	`62`	`+ ""usages"" : [`
`63`	`63`	`""Player1"", ""Player2""`
`64`	`64`	`]`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -776,7 +776,7 @@ public void Actions_InteractiveRebinding_IfDeviceHasUsages_UsagesAreAppliedToOve`
`776`	`776`	`var action = new InputAction(binding: "<Gamepad>/buttonSouth");`
`777`	`777`
`778`	`778`	`var rightHand = InputSystem.AddDevice<Gamepad>();`
`779`		`- InputSystem.SetDeviceUsage(rightHand, CommonUsages.RightHand);`
	`779`	`+ InputSystem.SetDeviceUsage(rightHand, Usages.RightHand);`
`780`	`780`
`781`	`781`	`using (var rebind = new InputActionRebindingExtensions.RebindingOperation().WithAction(action).Start())`
`782`	`782`	`{`
`@@ -1122,8 +1122,8 @@ public void Actions_InteractiveRebinding_IfDeviceHasMultipleUsages_UsagesAreAppl`
`1122`	`1122`
`1123`	`1123`	`var rightHandVertical = InputSystem.AddDevice<Gamepad>();`
`1124`	`1124`
`1125`		`- InputSystem.SetDeviceUsage(rightHandVertical, CommonUsages.RightHand);`
`1126`		`- InputSystem.AddDeviceUsage(rightHandVertical, CommonUsages.Vertical);`
	`1125`	`+ InputSystem.SetDeviceUsage(rightHandVertical, Usages.RightHand);`
	`1126`	`+ InputSystem.AddDeviceUsage(rightHandVertical, Usages.Vertical);`
`1127`	`1127`
`1128`	`1128`	`using (var rebind = new InputActionRebindingExtensions.RebindingOperation().WithAction(action).Start())`
`1129`	`1129`	`{`
Original file line number	Diff line number	Diff line change
`@@ -217,14 +217,14 @@ public void Editor_DomainReload_CanRestoreDevicesBuiltWithDynamicallyGeneratedLa`
`217`	`217`	`public void Editor_DomainReload_PreservesUsagesOnDevices()`
`218`	`218`	`{`
`219`	`219`	`var device = InputSystem.AddDevice<Gamepad>();`
`220`		`- InputSystem.SetDeviceUsage(device, CommonUsages.LeftHand);`
	`220`	`+ InputSystem.SetDeviceUsage(device, Usages.LeftHand);`
`221`	`221`
`222`	`222`	`SimulateDomainReload();`
`223`	`223`
`224`	`224`	`var newDevice = InputSystem.devices[0];`
`225`	`225`
`226`	`226`	`Assert.That(newDevice.usages, Has.Count.EqualTo(1));`
`227`		`- Assert.That(newDevice.usages, Has.Exactly(1).EqualTo(CommonUsages.LeftHand));`
	`227`	`+ Assert.That(newDevice.usages, Has.Exactly(1).EqualTo(Usages.LeftHand));`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`// We have code that will automatically query the enabled state of devices on creation`
Original file line number	Diff line number	Diff line change
`@@ -2556,7 +2556,7 @@ public void PlayerInput_WhenOverridingDeviceLayout_LostDeviceShouldBeResolvedAnd`
`2556`	`2556`	`{`
`2557`	`2557`	`""name"" : ""GamepadPlayerUsageTags"",`
`2558`	`2558`	`""extend"" : ""Gamepad"",`
`2559`		`- ""commonUsages"" : [`
	`2559`	`+ ""usages"" : [`
`2560`	`2560`	`""Player1"", ""Player2""`
`2561`	`2561`	`]`
`2562`	`2562`	`}`