Implement MIDI input support

osu.Framework.Android/AndroidGameHost.cs

@@ -46,7 +46,7 @@ public override ITextInputSource GetTextInput()
             => new AndroidTextInput(gameView);
 
         protected override IEnumerable<InputHandler> CreateAvailableInputHandlers()
-            => new InputHandler[] { new AndroidKeyboardHandler(gameView), new AndroidTouchHandler(gameView) };
+            => new InputHandler[] { new AndroidKeyboardHandler(gameView), new AndroidTouchHandler(gameView), new MidiInputHandler() };
 
         protected override Storage GetStorage(string baseName)
             => new AndroidStorage(baseName, this);

osu.Framework.Tests/Visual/Input/TestSceneMidi.cs

@@ -0,0 +1,102 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input;
+using osu.Framework.Input.Events;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Framework.Tests.Visual.Input
+{
+    public class TestSceneMidi : FrameworkTestScene
+    {
+        public TestSceneMidi()
+        {
+            var keyFlow = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+            };
+
+            for (MidiKey k = MidiKey.A0; k < MidiKey.C8; k++)
+                keyFlow.Add(new MidiKeyHandler(k));
+
+            Child = keyFlow;
+        }
+
+        protected override bool OnMidiDown(MidiDownEvent e)
+        {
+            Console.WriteLine(e);
+            return base.OnMidiDown(e);
+        }
+
+        protected override bool OnMidiUp(MidiUpEvent e)
+        {
+            Console.WriteLine(e);
+            return base.OnMidiUp(e);
+        }
+
+        protected override bool Handle(UIEvent e)
+        {
+            if (!(e is MouseEvent))
+                Console.WriteLine("Event: " + e);
+            return base.Handle(e);
+        }
+
+        private class MidiKeyHandler : CompositeDrawable
+        {
+            private readonly Drawable background;
+
+            public override bool HandleNonPositionalInput => true;
+
+            private readonly MidiKey key;
+
+            public MidiKeyHandler(MidiKey key)
+            {
+                this.key = key;
+
+                Size = new Vector2(50);
+
+                InternalChildren = new[]
+                {
+                    background = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = Color4.DarkGreen,
+                        Alpha = 0,
+                        Child = new Box { RelativeSizeAxes = Axes.Both }
+                    },
+                    new SpriteText
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Text = key.ToString().Replace("Sharp", "#")
+                    }
+                };
+            }
+
+            protected override bool OnMidiDown(MidiDownEvent e)
+            {
+                if (e.Key != key)
+                    return base.OnMidiDown(e);
+
+                background.FadeIn(100, Easing.OutQuint);
+                return true;
+            }
+
+            protected override bool OnMidiUp(MidiUpEvent e)
+            {
+                if (e.Key != key)
+                    return base.OnMidiUp(e);
+
+                background.FadeOut(100);
+                return true;
+            }
+        }
+    }
+}

osu.Framework.iOS/IOSGameHost.cs

@@ -87,7 +87,7 @@ protected override void PerformExit(bool immediately)
         public override ITextInputSource GetTextInput() => new IOSTextInput(gameView);
 
         protected override IEnumerable<InputHandler> CreateAvailableInputHandlers() =>
-            new InputHandler[] { new IOSTouchHandler(gameView), keyboardHandler = new IOSKeyboardHandler(gameView), rawKeyboardHandler = new IOSRawKeyboardHandler() };
+            new InputHandler[] { new IOSTouchHandler(gameView), keyboardHandler = new IOSKeyboardHandler(gameView), rawKeyboardHandler = new IOSRawKeyboardHandler(), new MidiInputHandler() };
 
         protected override Storage GetStorage(string baseName) => new IOSStorage(baseName, this);
 

osu.Framework/Graphics/Drawable.cs

@@ -1910,6 +1910,12 @@ public bool TriggerEvent(UIEvent e)
                 case JoystickReleaseEvent joystickRelease:
                     return OnJoystickRelease(joystickRelease);
 
+                case MidiDownEvent midiDown:
+                    return OnMidiDown(midiDown);
+
+                case MidiUpEvent midiUp:
+                    return OnMidiUp(midiUp);
+
                 default:
                     return Handle(e);
             }
@@ -1954,6 +1960,8 @@ protected virtual void OnFocusLost(FocusLostEvent e)
         protected virtual bool OnKeyUp(KeyUpEvent e) => Handle(e);
         protected virtual bool OnJoystickPress(JoystickPressEvent e) => Handle(e);
         protected virtual bool OnJoystickRelease(JoystickReleaseEvent e) => Handle(e);
+        protected virtual bool OnMidiDown(MidiDownEvent e) => Handle(e);
+        protected virtual bool OnMidiUp(MidiUpEvent e) => Handle(e);
 
         #endregion
 

osu.Framework/Input/Events/MidiDownEvent.cs

@@ -0,0 +1,16 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using JetBrains.Annotations;
+using osu.Framework.Input.States;
+
+namespace osu.Framework.Input.Events
+{
+    public class MidiDownEvent : MidiEvent
+    {
+        // TODO: velocity
+
+        public MidiDownEvent([NotNull] InputState state, MidiKey key)
+            : base(state, key) { }
+    }
+}

osu.Framework/Input/Events/MidiEvent.cs

@@ -0,0 +1,38 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using JetBrains.Annotations;
+using osu.Framework.Extensions.TypeExtensions;
+using osu.Framework.Input.States;
+
+namespace osu.Framework.Input.Events
+{
+    public abstract class MidiEvent : UIEvent
+    {
+        public readonly MidiKey Key;
+
+        /// <summary>
+        /// Whether a specific key is pressed.
+        /// </summary>
+        public bool IsPressed(MidiKey key) => CurrentState.Midi.Keys.IsPressed(key);
+
+        /// <summary>
+        /// Whether any key is pressed.
+        /// </summary>
+        public bool HasAnyKeyPressed => CurrentState.Midi.Keys.HasAnyButtonPressed;
+
+        /// <summary>
+        /// List of currently pressed keys.
+        /// </summary>
+        public IEnumerable<MidiKey> PressedKeys => CurrentState.Midi.Keys;
+
+        public MidiEvent([NotNull] InputState state, MidiKey key)
+            : base(state)
+        {
+            this.Key = key;
+        }
+
+        public override string ToString() => $"{GetType().ReadableName()}({Key})";
+    }
+}

osu.Framework/Input/Events/MidiUpEvent.cs

@@ -0,0 +1,16 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using JetBrains.Annotations;
+using osu.Framework.Input.States;
+
+namespace osu.Framework.Input.Events
+{
+    public class MidiUpEvent : MidiEvent
+    {
+        // TODO: velocity
+
+        public MidiUpEvent([NotNull] InputState state, MidiKey key)
+            : base(state, key) { }
+    }
+}

osu.Framework/Input/Handlers/MidiInputHandler.cs

@@ -0,0 +1,107 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Commons.Music.Midi;
+using osu.Framework.Input.StateChanges;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Framework.Threading;
+
+namespace osu.Framework.Input.Handlers
+{
+    public class MidiInputHandler : InputHandler
+    {
+        public override bool IsActive => true;
+        public override int Priority => 0;
+
+        private ScheduledDelegate scheduledRefreshDevices;
+
+        private readonly Dictionary<string, IMidiInput> openedDevices = new Dictionary<string, IMidiInput>();
+
+        public override bool Initialize(GameHost host)
+        {
+            // Try to initialize. This can throw on Linux if asound cannot be found.
+            try {
+                var unused = MidiAccessManager.Default.Inputs.ToList();
+            } catch (Exception e) {
+                Logger.Error(e, RuntimeInfo.OS == RuntimeInfo.Platform.Linux
+                    ? "Couldn't list input devices, is libasound2-dev installed?"
+                    : "Couldn't list input devices.");
+                return false;
+            }
+
+            Enabled.BindValueChanged(e =>
+            {
+                if (e.NewValue)
+                {
+                    host.InputThread.Scheduler.Add(scheduledRefreshDevices = new ScheduledDelegate(refreshDevices, 0, 500));
+                }
+                else {
+                    scheduledRefreshDevices?.Cancel();
+
+                    foreach (var value in openedDevices.Values) {
+                        value.MessageReceived -= onMidiMessageReceived;
+                    }
+
+                    openedDevices.Clear();
+                }
+            }, true);
+
+            return true;
+        }
+
+        private void refreshDevices()
+        {
+            var inputs = MidiAccessManager.Default.Inputs.ToList();
+
+            // check removed devices
+            foreach (string key in openedDevices.Keys.ToArray()) {
+                var value = openedDevices[key];
+
+                if (inputs.All(i => i.Id != key)) {
+                    value.MessageReceived -= onMidiMessageReceived;
+                    openedDevices.Remove(key);
+
+                    Logger.Log($"Disconnected MIDI device: {value.Details.Name}");
+                }
+            }
+
+            // check added devices
+            foreach (IMidiPortDetails input in inputs) {
+                if (openedDevices.All(x => x.Key != input.Id)) {
+                    var newInput = MidiAccessManager.Default.OpenInputAsync(input.Id).Result;
+                    newInput.MessageReceived += onMidiMessageReceived;
+                    openedDevices[input.Id] = newInput;
+
+                    Logger.Log($"Connected MIDI device: {newInput.Details.Name}");
+                }
+            }
+        }
+
+        private void onMidiMessageReceived(object sender, MidiReceivedEventArgs e)
+        {
+            var events = MidiEvent.Convert(e.Data, e.Start, e.Length);
+
+            foreach (MidiEvent midiEvent in events) {
+                var key = midiEvent.Msb;
+                var velocity = midiEvent.Lsb;
+                Logger.Log("Event " + midiEvent);
+
+                switch (midiEvent.EventType) {
+                    case MidiEvent.NoteOn:
+                        Logger.Log($"NoteOn: {(MidiKey)key}/{velocity/64f:P}");
+                        PendingInputs.Enqueue(new MidiKeyInput((MidiKey)midiEvent.Msb, true));
+                        break;
+
+                    case MidiEvent.NoteOff:
+                        Logger.Log($"NoteOff: {(MidiKey)key}/{velocity/64f:P}");
+                        PendingInputs.Enqueue(new MidiKeyInput((MidiKey)midiEvent.Msb, false));
+                        break;
+                }
+            }
+        }
+    }
+}

osu.Framework/Input/InputManager.cs

@@ -53,7 +53,7 @@ public abstract class InputManager : Container, IInputStateChangeHandler
         /// The initial input state. <see cref="CurrentState"/> is always equal (as a reference) to the value returned from this.
         /// <see cref="InputState.Mouse"/>, <see cref="InputState.Keyboard"/> and <see cref="InputState.Joystick"/> should be non-null.
         /// </summary>
-        protected virtual InputState CreateInitialState() => new InputState(new MouseState { IsPositionValid = false }, new KeyboardState(), new JoystickState());
+        protected virtual InputState CreateInitialState() => new InputState(new MouseState { IsPositionValid = false }, new KeyboardState(), new JoystickState(), new MidiState());
 
         /// <summary>
         /// The last processed state.
@@ -429,6 +429,20 @@ protected virtual void HandleJoystickButtonStateChange(ButtonStateChangeEvent<Jo
             }
         }
 
+        protected virtual void HandleMidiKeyStateChange(MidiStateChangeEvent midiKeyStateChange)
+        {
+            var state = midiKeyStateChange.State;
+            var key = midiKeyStateChange.Button;
+            var kind = midiKeyStateChange.Kind;
+
+            if (kind == ButtonStateChangeKind.Pressed) {
+                handleMidiKeyDown(state, key);
+            }
+            else {
+                handleMidiKeyUp(state, key);
+            }
+        }
+
         public virtual void HandleInputStateChange(InputStateChangeEvent inputStateChange)
         {
             switch (inputStateChange)
@@ -452,6 +466,10 @@ public virtual void HandleInputStateChange(InputStateChangeEvent inputStateChang
                 case ButtonStateChangeEvent<JoystickButton> joystickButtonStateChange:
                     HandleJoystickButtonStateChange(joystickButtonStateChange);
                     return;
+
+                case MidiStateChangeEvent midiKeyStateChange:
+                    HandleMidiKeyStateChange(midiKeyStateChange);
+                    return;
             }
         }
 
@@ -495,6 +513,10 @@ protected virtual void HandleMouseButtonStateChange(ButtonStateChangeEvent<Mouse
 
         private bool handleJoystickRelease(InputState state, JoystickButton button) => PropagateBlockableEvent(NonPositionalInputQueue, new JoystickReleaseEvent(state, button));
 
+        private bool handleMidiKeyDown(InputState state, MidiKey key) => PropagateBlockableEvent(NonPositionalInputQueue, new MidiDownEvent(state, key));
+
+        private bool handleMidiKeyUp(InputState state, MidiKey key) => PropagateBlockableEvent(NonPositionalInputQueue, new MidiUpEvent(state, key));
+
         /// <summary>
         /// Triggers events on drawables in <paramref cref="drawables"/> until it is handled.
         /// </summary>