Permissions Integration

The Web Midi API is a [=powerful feature=] that is identified by the [=powerful feature/name=] "midi". It integrates with [[[Permissions]]] by defining the following permission-related flags:

[=powerful feature/permission descriptor type=]

              dictionary MidiPermissionDescriptor : PermissionDescriptor {
                boolean sysex = false;
              };
            

`{name: "midi", sysex: true}` is [=PermissionDescriptor/stronger than=] `{name: "midi", sysex: false}`.

Permissions Policy Integration

The Web Midi API defines a [=policy-controlled feature=] named "midi" which has a [=policy-controlled feature/default allowlist=] of `'self'`.

Extensions to the Navigator interface

            partial interface Navigator {
              [SecureContext]
              Promise <MIDIAccess> requestMIDIAccess(optional MIDIOptions options = {});
            };
          

requestMIDIAccess() method

When invoked, returns a Promise object representing a request for access to [=MIDI devices=] on the user's system.

Requesting MIDI access SHOULD prompt the user for access to MIDI devices, particularly if [=System Exclusive=] access is requested. In some scenarios, this permission may have already been implicitly or explicitly granted, in which case this prompt may not appear. If the user gives express permission or the call is otherwise approved, the vended Promise is resolved. The underlying system may choose to allow the user to select specific [=MIDI interfaces=] to expose to this API (i.e. pick and choose interfaces on an individual basis), although this is not required. The system may also choose to prompt (or not) based on whether [=System Exclusive=] support is requested, as [=System Exclusive=] access has greater privacy and security implications.

If the user declines or the call is denied for any other reason, the Promise is rejected with a {{DOMException}} parameter.

When the {{requestMIDIAccess()}} method is called, the user agent MUST run the following steps:

1. Let promise be a new Promise object and resolver be its associated resolver.

2. Return promise and run the following steps asynchronously.

3. Let document be the calling context's [=Document=].

4. If document is not [=allowed to use=] the [=policy-controlled feature=] named midi, jump to the step labeled failure below.

5. Optionally, e.g. based on a previously-established user preference, for security reasons, or due to platform limitations, jump to the step labeled failure below.

6. Optionally, e.g. based on a previously-established user preference, jump to the step labeled success below.

7. Prompt the user in a user-agent-specific manner for permission to provide the entry script's origin with a {{MIDIAccess}} object representing control over user's [=MIDI devices=]. This prompt may be contingent upon whether [=System Exclusive=] support was requested, and may allow the user to enable or disable that access.

   If permission is denied, jump to the step labeled failure below. If the user never responds, this algorithm will never progress beyond this step. If permission is granted, continue the following steps.

8. success: Let access be a new {{MIDIAccess}} object. (It is possible to call requestMIDIAccess() multiple times; this may prompt the user multiple times, so it may not be best practice, and the same instance of MIDIAccess will not be returned each time.)

9. Call resolver's accept(value) method with access as value argument.

10. Terminate these steps.

11. failure: Let error be a new {{DOMException}}. This exception's .name should be {{"NotAllowedError"}} if the user or their security settings denied the application from creating a MIDIAccess instance with the requested options, or if the error is the result of document not being [=allowed to use=] the feature, {{"AbortError"}} if the page is going to be closed for a user navigation, {{"InvalidStateError"}} if the underlying systems raise any errors, or otherwise it should be {{"NotSupportedError"}}.

12. Call resolver's reject(value) method with error as value argument.

            dictionary MIDIOptions {
              boolean sysex;
              boolean software;
            };
          

MIDIInputMap Interface

          [SecureContext, Exposed=(Window,Worker)] interface MIDIInputMap {
            readonly maplike <DOMString, MIDIInput>;
          };
        

The {{MIDIInputMap}} is a maplike interface whose value is a {{MIDIInput}} instance and key is its ID.

This type is used to represent all the currently available MIDI input ports. This enables:

    // to tell how many entries there are:
    let numberOfMIDIInputs = inputs.size;

    // add each of the ports to a <select> box
    inputs.forEach( function( port, key ) {
      let opt = document.createElement("option");
      opt.text = port.name;
      document.getElementById("inputportselector").add(opt);
    });

    // or you could express in ECMAScript 6 as:
    for (let input of inputs.values()) {
      let opt = document.createElement("option");
      opt.text = input.name;
      document.getElementById("inputportselector").add(opt);
    }

MIDIOutputMap Interface

          [SecureContext, Exposed=(Window,Worker)] interface MIDIOutputMap {
            readonly maplike <DOMString, MIDIOutput>;
          };
        

The {{MIDIOutputMap}} is a maplike interface whose value is a {{MIDIOutput}} instance and key is its ID.

This type is used to represent all the currently available [=MIDI output ports=]. This enables:

    // to tell how many entries there are:
    let numberOfMIDIOutputs = outputs.size;

    // add each of the ports to a <select> box
    outputs.forEach( function( port, key ) {
      let opt = document.createElement("option");
      opt.text = port.name;
      document.getElementById("outputportselector").add(opt);
    });

    // or you could express in ECMAScript 6 as:
    for (let output of outputs.values()) {
      let opt = document.createElement("option");
      opt.text = output.name;
      document.getElementById("outputportselector").add(opt);
    }

MIDIAccess Interface

This interface provides the methods to list MIDI input and output devices, and obtain access to an individual device.

        [SecureContext, Exposed=(Window,Worker), Transferable] interface MIDIAccess: EventTarget {
          readonly attribute MIDIInputMap inputs;
          readonly attribute MIDIOutputMap outputs;
          attribute EventHandler onstatechange;
          readonly attribute boolean sysexEnabled;
        };
      

inputs

The [=MIDI input ports=] available to the system.

outputs

The [=MIDI output ports=] available to the system.

onstatechange

The handler called when a new port is connected or an existing port changes the state attribute.

This [=event handler=], of type {{MIDIConnectionEvent}}, MUST be supported by all objects implementing the {{MIDIAccess}} interface.

It is important to understand that leaving an {{EventHandler}} attached to this object will prevent it from being garbage-collected; when finished using the {{MIDIAccess}}, you should remove any {{onstatechange}} listeners.

Whenever a previously unavailable MIDI port becomes available for use, or an existing port changes the state attribute, the user agent SHOULD run the following steps:

1. Let |port:MIDIPort| be the {{MIDIPort}} corresponding to the newly-available, or the existing port.
2. [=Fire an event=] named "statechange" at the {{MIDIAccess}}, using {{MIDIConnectionEvent}} with {{MIDIConnectionEvent/port}} set to |port|.

sysexEnabled

This attribute informs the user whether [=System Exclusive=] support is enabled on this MIDIAccess.

MIDIPort Interface

This interface represents a MIDI input or output port.

        [SecureContext, Exposed=(Window,Worker)] interface MIDIPort: EventTarget {
          readonly attribute DOMString id;
          readonly attribute DOMString? manufacturer;
          readonly attribute DOMString? name;
          readonly attribute MIDIPortType type;
          readonly attribute DOMString? version;
          readonly attribute MIDIPortDeviceState state;
          readonly attribute MIDIPortConnectionState connection;
          attribute EventHandler onstatechange;
          Promise <MIDIPort> open();
          Promise <MIDIPort> close();
        };
      

id

A unique ID of the port. This can be used by developers to remember ports the user has chosen for their application. The User Agent MUST ensure that the {{MIDIPort/id}} is unique to only that port. The User Agent SHOULD ensure that the id is maintained across instances of the application - e.g., when the system is rebooted - and when a device is removed from the system. Applications may want to cache these ids locally to re-create a MIDI setup. Some systems may not support completely unique persistent identifiers; in such cases, it will be more challenging to maintain identifiers when another interface is added or removed from the system. (This might throw off the index of the requested port.) It is expected that the system will do the best it can to match a port across instances of the MIDI API: for example, an implementation may opaquely use some form of hash of the port interface manufacturer, name and index as the id, so that a reference to that port id is likely to match the port when plugged in. Applications may use the comparison of id of MIDIPorts to test for equality.

manufacturer

The manufacturer of the port.

name

The system name of the port.

type

A descriptor property to distinguish whether the port is an input or an output port. For {{MIDIOutput}}, this MUST be "output". For {{MIDIInput}}, this MUST be "input".

version

The version of the port.

state

The state of the device.

connection

The state of the connection to the device.

onstatechange

The handler called when an existing port changes its state or connection attributes.

This [=event handler=], of type "statechange", MUST be supported by all objects implementing {{MIDIPort}} interface.

It is important to understand that leaving an {{EventHandler}} attached to this object will prevent it from being garbage-collected; when finished using the {{MIDIPort}}, you should remove any {{MIDIPort/onstatechange}} listeners.

open

Makes the [=MIDI device=] corresponding to the {{MIDIPort}} explicitly available. Note that this call is NOT required in order to use the {{MIDIPort}}- calling send() on a {{MIDIOutput}} or attaching a MIDIMessageEvent handler on a {{MIDIInput}} will cause an implicit open(). The underlying implementation may not need to do anything in response to this call. However, some underlying implementations may not be able to support shared access to [=MIDI devices=], so using explicit open() and close() calls will enable MIDI applications to predictably control this exclusive access to devices.

When invoked, this method returns a Promise object representing a request for access to the given MIDI port on the user's system.

If the port device has a state of "connected", when access to the port has been obtained (and the port is ready for input or output), the vended Promise is resolved.

If access to a connected port is not available (for example, the port is already in use in an exclusive-access-only platform), the Promise is rejected (if any) is invoked.

If open() is called on a port that is "disconnected", the port's .connection will transition to "pending", until the port becomes "connected" or all references to it are dropped.

When this method is called, the user agent MUST run the algorithm to open a MIDIPort:

1. Let promise be a new Promise object and resolver be its associated resolver.

2. Return promise and run the following steps asynchronously.

3. Let port be the given {{MIDIPort}} object.

4. If the device's connection is already "open" (e.g. open() has already been called on this {{MIDIPort}}, or the port has been implicitly opened), jump to the step labeled success below.

5. If the device's connection is "pending" (i.e. the connection had been opened and the device was subsequently disconnected), jump to the step labeled success below.

6. If the device's state is "disconnected", change the connection attribute of the {{MIDIPort}} to "pending", and enqueue a new MIDIConnectionEvent to the statechange handler of the {{MIDIAccess}} and to the statechange handler of the {{MIDIPort}} and jump to the step labeled success below.

7. Attempt to obtain access to the given [=MIDI device=] in the system. If the device is unavailable (e.g. is already in use by another process and cannot be opened, or is disconnected), jump to the step labeled failure below. If the device is available and access is obtained, continue the following steps.

8. Change the connection attribute of the MIDIPort to "open", and enqueue a new {{MIDIConnectionEvent}} to the statechange handler of the {{MIDIAccess}} and to the statechange handler of the {{MIDIPort}}.

9. If this port is an output port and has any pending data that is waiting to be sent, asynchronously begin sending that data.

10. success: Call resolver's accept(value) method with port as value argument.

11. Terminate these steps.

12. failure: Let error be a new {{DOMException}}. This exception's .name should be "InvalidAccessError" if the port is unavailable.

13. Call resolver's reject(value) method with error as value argument.

close

Makes the [=MIDI device=] corresponding to the {{MIDIPort}} explicitly unavailable (subsequently changing the state from "open" to "closed"). Note that successful invocation of this method will result in [=MIDI messages=] no longer being delivered to MIDIMessageEvent handlers on a {{MIDIInput}} (although setting a new handler will cause an implicit open()).

The underlying implementation may not need to do anything in response to this call. However, some underlying implementations may not be able to support shared access to [=MIDI devices=], and the explicit close() call enables MIDI applications to ensure other applications can gain access to devices.

When invoked, this method returns a Promise object representing a request for access to the given MIDI port on the user's system. When the port has been closed (and therefore, in exclusive access systems, the port is available to other applications), the vended Promise is resolved. If the port is disconnected, the Promise is rejected.

When the close() method is called, the user agent MUST run the following steps:

1. Let promise be a new Promise object and resolver be its associated resolver.

2. Return promise and run the following steps asynchronously.

3. Let port be the given {{MIDIPort}} object.

4. If the port is already closed (its .connection is "closed" - e.g. the port has not yet been implicitly or explicitly opened, or close() has already been called on this {{MIDIPort}}), jump to the step labeled closed below.

5. If the port is an input port, skip to the next step. If the output port's .state is not "connected", clear all pending send data and skip to the next step. Clear any pending send data in the system with timestamps in the future, then finish sending any send messages with no timestamp or with a timestamp in the past or present, prior to proceeding to the next step.

6. Close access to the port in the underlying system if open, and release any blocking resources in the underlying system.

7. Change the connection attribute of the MIDIPort to "closed", and enqueue a new {{MIDIConnectionEvent}} to the statechange handler of the {{MIDIAccess}} and to the statechange handler of the {{MIDIPort}}.

8. closed: Call resolver's accept(value) method with port as value argument.

9. Terminate these steps.

Whenever the MIDI port corresponding to the {{MIDIPort}} changes the state attribute, the user agent SHOULD run the following steps:

1. Let |port:MIDIPort| be the {{MIDIPort}}.

2. [=Fire an event=] named statechange at the {{MIDIPort}}, and statechange at the {{MIDIAccess}}, using {{MIDIConnectionEvent}} with the {{MIDIConnectionEvent/port}} attribute set to |port|.

          [SecureContext, Exposed=(Window,Worker)] interface MIDIInput: MIDIPort {
            attribute EventHandler onmidimessage;
          };
        

          [SecureContext, Exposed=(Window,Worker)] interface MIDIOutput : MIDIPort {
            undefined send(sequence<octet> data, optional DOMHighResTimeStamp timestamp = 0);
            undefined clear();
          };
          

          enum MIDIPortType {
            "input",
            "output",
          };
        

        enum MIDIPortDeviceState {
          "disconnected",
          "connected",
        };
      

        enum MIDIPortConnectionState {
          "open",
          "closed",
          "pending",
        };
      

MIDIMessageEvent Interface

An event object implementing this interface is passed to a {{MIDIInput}}'s onmidimessage handler when [=MIDI messages=] are received. Note that the DOM {{Event}} timeStamp attribute is defined as a {{DOMHighResTimeStamp}}, and represents the high-resolution time of when the event was received or is to be sent.

        [SecureContext, Exposed=(Window,Worker)]
        interface MIDIMessageEvent : Event {
          constructor(DOMString type, optional MIDIMessageEventInit eventInitDict = {});
          readonly attribute Uint8Array? data;
        };
      

data

A Uint8Array containing the MIDI data bytes of a single [=MIDI message=].

          dictionary MIDIMessageEventInit: EventInit {
            Uint8Array data;
          };
        

MIDIConnectionEvent Interface

An event object implementing this interface is passed to a {{MIDIAccess}}' onstatechange handler when a new port becomes available (for example, when a [=MIDI device=] is first plugged in to the computer), when a previously-available port becomes unavailable, or becomes available again (for example, when a [=MIDI interface=] is disconnected, then reconnected) and (if present) is also passed to the {{MIDIPort/onstatechange}} handlers for any {{MIDIPort}}s referencing the port.

When a {{MIDIPort}} is in the "pending" state and the device is reconnected to the host system, prior to firing a statechange event the [=algorithm to open a MIDIPort=] is run on it to attempt to reopen the port. If this transition fails (e.g. the Port is reserved by something else in the underlying system, and therefore unavailable for use), the connection state moves to "closed", else it transitions back to "open". This is done prior to the statechange event for the device state change so that the event will reflect the final connection state as well as the device state.

Some underlying systems may not provide notification events for device connection status; such systems may have long time delays as they poll for new devices infrequently. As such, it is suggested that heavy reliance on connection events not be used.

        [SecureContext, Exposed=(Window,Worker)]
        interface MIDIConnectionEvent : Event {
          constructor(DOMString type, optional MIDIConnectionEventInit eventInitDict = {});
          readonly attribute MIDIPort? port;
        };
      

port

The port that has been connected or disconnected.

          dictionary MIDIConnectionEventInit: EventInit {
            MIDIPort port;
          };
        

Changes since Working Draft 17 March 2015