[Web MIDI] Use Android MIDI API.

media/midi/java/src/org/chromium/media/midi/MidiDeviceAndroid.java

Index: media/midi/java/src/org/chromium/media/midi/MidiDeviceAndroid.java
diff --git a/media/midi/java/src/org/chromium/media/midi/MidiDeviceAndroid.java b/media/midi/java/src/org/chromium/media/midi/MidiDeviceAndroid.java
new file mode 100644
index 0000000000000000000000000000000000000000..e78784f347630ac0272c72f015baf41a52ab1822
--- /dev/null
+++ b/media/midi/java/src/org/chromium/media/midi/MidiDeviceAndroid.java
@@ -0,0 +1,132 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.media.midi;
+
+import android.media.midi.MidiDevice;
+import android.media.midi.MidiDeviceInfo;
+
+import org.chromium.base.annotations.CalledByNative;
+import org.chromium.base.annotations.JNINamespace;
+
+@JNINamespace("media::midi")
+/**
+ * A class implementing media::midi::MidiDeviceAndroid functionality.
+ */
+class MidiDeviceAndroid {
+    /**
+     * The underlying device.
+     */
+    private MidiDevice mDevice;
+    /**
+     * The input ports in the device.
+     */
+    private MidiInputPortAndroid[] mInputPorts;
+    /**
+     * The output ports in the device.
+     */
+    private MidiOutputPortAndroid[] mOutputPorts;
+    /**
+     * True when the device is open.
+     */
+    private boolean mIsOpen;
+
+    /**
+     * constructor
+     * @param device the underlying device
+     */
+    MidiDeviceAndroid(MidiDevice device) {
+        mIsOpen = true;
+        mDevice = device;
+        // Note we use "input" and "output" in the WebMIDI manner.
+
+        mOutputPorts = new MidiOutputPortAndroid[getInfo().getInputPortCount()];
+        for (int i = 0; i < mOutputPorts.length; ++i) {
+            mOutputPorts[i] = new MidiOutputPortAndroid(device.openInputPort(i));

[philburk, 2015/08/19 01:40:15]

This will open all the input ports on the device in exclusive access mode. An
input port can have only one writer. So this will prevent other apps from
sharing the device. Can you open input ports only as needed?

[philburk, 2015/08/19 01:40:15]

openInputPort() can fail and return null if the port is already in use by
another app.

[yhirano, 2015/08/19 06:32:02]

Done.

[yhirano, 2015/08/19 06:32:02]

Hm, WebMIDI spec has explicit open / close, but we haven't implemented it yet.
I added open() method for ports and made it and close() callable from the C++
layer.
I call open() from media::midi::MidiManagerAndroid as a workaround and added
TODO. Is that OK?

Please note that even with the current implementation midi ports are not opened
until a web page uses WebMIDI functions.

[philburk, 2015/08/19 20:22:26]

Maybe. I am not sure how your code works. I just know the Android input ports
should not be opened if they are not used. You could even dynamically open it on
the first write and then close it when the page is left.

A WebMidi app might want to write MIDI to an Android MIDI processing app that
then writes to an Android synth. But Chrome may open the synth ports and block
the processing app. That would be bad.
When are they closed?

[yhirano, 2015/08/20 07:38:29]

With this CL MidiInputPort is opened when the first send signal arrives from the
renderer process.

To "close it when the page is left" is a bit difficult and I would like to
implement it in a separate CL.
 
Never. It should be fixed, though.

[Takashi Toyoshima, 2015/09/07 16:42:19]

Web MIDI introduced open() and close() methods recently in order to make it easy
to implement backend for Windows. Android will need it too.
But these open() and close() methods are not implemented yet, and will be
implemented in weeks. So I think it's ok to leave this TODO now. I think open()
and close() will be implemented before this new implementation goes out of the
experimental flag.

Since MidiManager and related classes are single instance, and shared from
multiple tabs running on isolated processes, we need to manage reference count
to realize open and close. That's why we can not easily implement open and close
in android specific implementation side. But, once all existing tabs are closed,
Chrome browser process exists and releases all devices now.

+        }
+
+        mInputPorts = new MidiInputPortAndroid[getInfo().getOutputPortCount()];
+        for (int i = 0; i < mInputPorts.length; ++i) {
+            mInputPorts[i] = new MidiInputPortAndroid(device.openOutputPort(i));
+        }
+    }
+
+    /**
+     * Returns true when the device is open.
+     */
+    boolean isOpen() {
+        return mIsOpen;
+    }
+
+    /**
+     * Closes the device.
+     */
+    void close() {
+        mIsOpen = false;
+        for (MidiInputPortAndroid port: mInputPorts) {
+            port.close();
+        }
+        for (MidiOutputPortAndroid port: mOutputPorts) {
+            port.close();
+        }
+    }
+
+    /**
+     * Returns the underlying device.
+     */
+    MidiDevice getDevice() {
+        return mDevice;
+    }
+
+    /**
+     * Returns the underlying device information.
+     */
+    MidiDeviceInfo getInfo() {
+        return mDevice.getInfo();
+    }
+
+    /**
+     * Returns the manufacturer name.
+     */
+    @CalledByNative
+    String getManufacturer() {
+        return getProperty(MidiDeviceInfo.PROPERTY_MANUFACTURER);
+    }
+
+    /**
+     * Returns the product name.
+     */
+    @CalledByNative
+    String getProduct() {
+        return getProperty(MidiDeviceInfo.PROPERTY_PRODUCT);
+    }
+
+    /**
+     * Returns the version string.
+     */
+    @CalledByNative
+    String getVersion() {
+        return getProperty(MidiDeviceInfo.PROPERTY_VERSION);
+    }
+
+    /**
+     * Returns the associated input ports.
+     */
+    @CalledByNative
+    MidiInputPortAndroid[] getInputPorts() {
+        return mInputPorts;
+    }
+
+    /**
+     * Returns the associated output ports.
+     */
+    @CalledByNative
+    MidiOutputPortAndroid[] getOutputPorts() {
+        return mOutputPorts;
+    }
+
+    private String getProperty(String name) {
+        return mDevice.getInfo().getProperties().getString(name);
+    }
+}