FIX: PlayerInput not hot-pairing devices without control schemes (#930).

Author: Rene Damm

Assets/Tests/InputSystem/Plugins/PlayerInputTests.cs

@@ -257,6 +257,32 @@ public void PlayerInput_CanBeUsedWithoutControlSchemes()
         Assert.That(playerInput.devices, Has.Count.EqualTo(2));
         Assert.That(playerInput.devices, Has.Exactly(1).SameAs(gamepad));
         Assert.That(playerInput.devices, Has.Exactly(1).SameAs(keyboard));
+
+        // Make sure that we restore pairing even if the device goes
+        // away temporarily.
+
+        InputSystem.RemoveDevice(gamepad);
+
+        Assert.That(playerInput.devices, Has.Count.EqualTo(1));
+        Assert.That(playerInput.devices, Has.Exactly(1).SameAs(keyboard));
+
+        InputSystem.AddDevice(gamepad);
+
+        Assert.That(playerInput.devices, Has.Count.EqualTo(2));
+        Assert.That(playerInput.devices, Has.Exactly(1).SameAs(gamepad));
+        Assert.That(playerInput.devices, Has.Exactly(1).SameAs(keyboard));
+
+        // Also, if we add another device now, it should get picked up, too. Note that
+        // this is special about the case of not using control schemes. When having control
+        // schemes, we switch in single-player entirely based on control schemes. When *not*
+        // having control schemes, we greedily grab everything that is compatible with the
+        // bindings we have.
+        var gamepad2 = InputSystem.AddDevice<Gamepad>();
+
+        Assert.That(playerInput.devices, Has.Count.EqualTo(3));
+        Assert.That(playerInput.devices, Has.Exactly(1).SameAs(gamepad));
+        Assert.That(playerInput.devices, Has.Exactly(1).SameAs(gamepad2));
+        Assert.That(playerInput.devices, Has.Exactly(1).SameAs(keyboard));
     }
 
     [Test]

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -25,6 +25,8 @@ however, it has to be formatted properly to pass verification tests.
 - Fixed missing custom editors for `AxisDeadzoneProcessor` and `StickDeadzoneProcessor` that link `min` and `max` values to input settings.
 - Fixed actions ending up being disabled if switching to a control scheme that has no binding for the action (case 1187377).
 - Fixed part of composite not being bound leading to subsequent part bindings not being functional (case 1189867).
+- Fixed `PlayerInput` not pairing devices added after it was enabled when not having control schemes.
+  * This problem would also show in the `SimpleDemo` sample when having the `CustomDeviceUsages` sample installed as well. Gamepads would not get picked up in that case.
 - Fixed `ArgumentNullException` when adding a device and a binding in an action map had an empty path (case 1187163).
 - Fixed bindings that are not associated with any control scheme not getting enabled with other control schemes as they should.
 

Packages/com.unity.inputsystem/InputSystem/InputManager.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
 using UnityEngine.InputSystem.Composites;
 using UnityEngine.InputSystem.Controls;
 using Unity.Collections.LowLevel.Unsafe;
@@ -10,7 +9,6 @@
 using UnityEngine.InputSystem.Processors;
 using UnityEngine.InputSystem.Interactions;
 using UnityEngine.InputSystem.Utilities;
-using Unity.Collections;
 using UnityEngine.InputSystem.Layouts;
 
 #if UNITY_EDITOR

Packages/com.unity.inputsystem/InputSystem/InputSystem.cs

@@ -981,18 +981,23 @@ public static IEnumerable<string> ListProcessors()
         /// </code>
         /// </example>
         /// </remarks>
+        /// <exception cref="ArgumentNullException">Delegate reference is <c>null</c>.</exception>
         /// <seealso cref="devices"/>
         /// <seealso cref="AddDevice{TDevice}"/>
         /// <seealso cref="RemoveDevice"/>
         public static event Action<InputDevice, InputDeviceChange> onDeviceChange
         {
             add
             {
+                if (value == null)
+                    throw new ArgumentNullException(nameof(value));
                 lock (s_Manager)
                     s_Manager.onDeviceChange += value;
             }
             remove
             {
+                if (value == null)
+                    throw new ArgumentNullException(nameof(value));
                 lock (s_Manager)
                     s_Manager.onDeviceChange -= value;
             }
@@ -1013,17 +1018,22 @@ public static event Action<InputDevice, InputDeviceChange> onDeviceChange
         /// to have handled the command. If a command is handled by a delegate in the list, it will
         /// not be sent on to the runtime.
         /// </remarks>
+        /// <exception cref="ArgumentNullException">Delegate reference is <c>null</c>.</exception>
         /// <seealso cref="InputDevice.ExecuteCommand{TCommand}"/>
         /// <seealso cref="IInputRuntime.DeviceCommand"/>
         public static event InputDeviceCommandDelegate onDeviceCommand
         {
             add
             {
+                if (value == null)
+                    throw new ArgumentNullException(nameof(value));
                 lock (s_Manager)
                     s_Manager.onDeviceCommand += value;
             }
             remove
             {
+                if (value == null)
+                    throw new ArgumentNullException(nameof(value));
                 lock (s_Manager)
                     s_Manager.onDeviceCommand -= value;
             }
@@ -1990,6 +2000,7 @@ public static int FindControls<TControl>(string path, ref InputControlList<TCont
         /// (see <see cref="InputState.AddChangeMonitor(InputControl,IInputStateChangeMonitor,long)"/>
         /// are usually a more efficient and convenient way to set this up.
         /// </remarks>
+        /// <exception cref="ArgumentNullException">Delegate reference is <c>null</c>.</exception>
         /// <seealso cref="QueueEvent(InputEventPtr)"/>
         /// <seealso cref="InputEvent"/>
         /// <seealso cref="Update"/>
@@ -1998,11 +2009,15 @@ public static event Action<InputEventPtr, InputDevice> onEvent
         {
             add
             {
+                if (value == null)
+                    throw new ArgumentNullException(nameof(value));
                 lock (s_Manager)
                     s_Manager.onEvent += value;
             }
             remove
             {
+                if (value == null)
+                    throw new ArgumentNullException(nameof(value));
                 lock (s_Manager)
                     s_Manager.onEvent -= value;
             }