Java MidiDevice类代码示例

import android.media.midi.MidiDevice; //导入依赖的package包/类
@Override
public void onPortSelected(final MidiPortWrapper wrapper) {
    close();
    final MidiDeviceInfo info = wrapper.getDeviceInfo();
    if (info != null) {
        mMidiManager.openDevice(info, new MidiManager.OnDeviceOpenedListener() {
                @Override
            public void onDeviceOpened(MidiDevice device) {
                if (device == null) {
                    Log.e(MidiConstants.TAG, "could not open " + info);
                } else {
                    mOpenDevice = device;
                    mInputPort = mOpenDevice.openInputPort(
                            wrapper.getPortIndex());
                    if (mInputPort == null) {
                        Log.e(MidiConstants.TAG, "could not open input port on " + info);
                    }
                }
            }
        }, null);
        // Don't run the callback on the UI thread because openInputPort might take a while.
    }
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
private void findMidiDevice() {
    MidiDeviceInfo[] infos = midiManager.getDevices();
    for(MidiDeviceInfo info : infos) {
        String name = info.getProperties().getString(MidiDeviceInfo.PROPERTY_NAME);
        logger.log("Found MIDI device named " + name);
        if(TEENSY_MIDI_NAME.equals(name)) {
            logger.log("^^^ using this device ^^^");
            isConnecting = true;
            midiManager.openDevice(info, new MidiManager.OnDeviceOpenedListener() {
                @Override
                public void onDeviceOpened(MidiDevice device) {
                    if (device == null) {
                        logger.log("Error, unable to open MIDI device");
                    } else {
                        logger.log("Opened MIDI device successfully!");
                        midiDevice = device;
                    }
                    isConnecting = false;
                }
            }, null);
            break;
        }
    }
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
/**
 * constructor
 * @param device the underlying device
 */
MidiDeviceAndroid(MidiDevice device) {
    mIsOpen = true;
    mDevice = device;
    // Note we use "input" and "output" in the Web MIDI manner.

    mOutputPorts = new MidiOutputPortAndroid[getInfo().getInputPortCount()];
    for (int i = 0; i < mOutputPorts.length; ++i) {
        mOutputPorts[i] = new MidiOutputPortAndroid(device, i);
    }

    mInputPorts = new MidiInputPortAndroid[getInfo().getOutputPortCount()];
    for (int i = 0; i < mInputPorts.length; ++i) {
        mInputPorts[i] = new MidiInputPortAndroid(device, i);
    }
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
private void onBluetoothDeviceOpen(final BluetoothDevice bluetoothDevice,
        final MidiDevice midiDevice) {
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            if (midiDevice != null) {
                BluetoothMidiDeviceTracker tracker = new BluetoothMidiDeviceTracker(
                        bluetoothDevice, midiDevice);
                mOpenDeviceListAdapter.addDevice(tracker);
            } else {
                Toast.makeText(MainActivity.this,
                        "MIDI device open failed!", Toast.LENGTH_LONG)
                        .show();
            }
        }
    });
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
@Override
protected void onActivityResult(int requestCode, int resultCode,
        Intent data) {
    if (requestCode == REQUEST_BLUETOOTH_SCAN && resultCode == RESULT_OK) {
        final BluetoothDevice fBluetoothDevice = (BluetoothDevice) data
                .getParcelableExtra("device");
        if (fBluetoothDevice != null) {
            Log.i(TAG, "Bluetooth device name = "
                    + fBluetoothDevice.getName()
                    + ", address = "
                    + fBluetoothDevice.getAddress());
            mMidiManager.openBluetoothDevice(fBluetoothDevice,
                    new MidiManager.OnDeviceOpenedListener() {
                        @Override
                        public void onDeviceOpened(MidiDevice device) {
                            onBluetoothDeviceOpen(fBluetoothDevice, device);
                        }
                    }, null);
        }
    }
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
@Override
public void onDeviceOpened(MidiDevice device) {
    this.device = device;
    stream(device.getInfo().getPorts())
            .filter(port -> port.getType() == MidiDeviceInfo.PortInfo.TYPE_OUTPUT).findFirst()
            .ifPresent(port -> device.openOutputPort(port.getPortNumber()).connect(this));
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
@Override
public void onPortSelected(final MidiPortWrapper wrapper) {
    Log.i(MidiConstants.TAG, "onPortSelected: " + wrapper);
    close();

    final MidiDeviceInfo info = wrapper.getDeviceInfo();
    if (info != null) {
        mMidiManager.openDevice(info, new MidiManager.OnDeviceOpenedListener() {

                @Override
            public void onDeviceOpened(MidiDevice device) {
                if (device == null) {
                    Log.e(MidiConstants.TAG, "could not open " + info);
                } else {
                    mOpenDevice = device;
                    mOutputPort = device.openOutputPort(wrapper.getPortIndex());
                    if (mOutputPort == null) {
                        Log.e(MidiConstants.TAG,
                                "could not open output port for " + info);
                        return;
                    }
                    mOutputPort.connect(mDispatcher);
                }
            }
        }, null);
        // Don't run the callback on the UI thread because openOutputPort might take a while.
    }
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
/**
 * Open a source device and connect its output port to the
 * destinationInputPort.
 *
 * @param sourceDeviceInfo
 * @param sourcePortIndex
 * @param destinationInputPort
 */
private void connectToDevicePort(final MidiDeviceInfo sourceDeviceInfo,
        final int sourcePortIndex,
        final MidiInputPort destinationInputPort,
        final OnPortsConnectedListener listener, final Handler handler) {
    mMidiManager.openDevice(sourceDeviceInfo,
            new MidiManager.OnDeviceOpenedListener() {
                @Override
                public void onDeviceOpened(MidiDevice device) {
                    if (device == null) {
                        Log.e(MidiConstants.TAG,
                                "could not open " + sourceDeviceInfo);
                        safeClose();
                        if (listener != null) {
                            listener.onPortsConnected(null);
                        }
                    } else {
                        Log.i(MidiConstants.TAG,
                                "connectToDevicePort opened "
                                        + sourceDeviceInfo);
                        // Device was opened so connect the ports.
                        mSourceDevice = device;
                        mConnection = device.connectPorts(
                                destinationInputPort, sourcePortIndex);
                        if (mConnection == null) {
                            Log.e(MidiConstants.TAG, "could not connect to "
                                    + sourceDeviceInfo);
                            safeClose();
                        }
                        if (listener != null) {
                            listener.onPortsConnected(mConnection);
                        }
                    }
                }
            }, handler);
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
@Override
public void onItemSelected(AdapterView<?> adapterView, View view, int i, long l) {
    System.out.println(i);
    m.openDevice(infos[midiDevice], new MidiManager.OnDeviceOpenedListener() {
        @Override
        public void onDeviceOpened(MidiDevice device) {
            if (device == null) {
                Toast.makeText(getApplicationContext(), "Could not open device!",
                        Toast.LENGTH_LONG).show();
            } else {
                inputPort = device.openInputPort(0);
            }
        }
    }, new Handler(Looper.getMainLooper()));
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
private void openDevice(final MidiDeviceInfo info) {
    mManager.openDevice(info, new MidiManager.OnDeviceOpenedListener() {
        @Override
        public void onDeviceOpened(MidiDevice device) {
            MidiManagerAndroid.this.onDeviceOpened(device, info);
        }
    }, mHandler);
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
private void onDeviceOpened(MidiDevice device, MidiDeviceInfo info) {
    mPendingDevices.remove(info);
    if (device != null) {
        MidiDeviceAndroid xdevice = new MidiDeviceAndroid(device);
        mDevices.add(xdevice);
        if (mIsInitialized) {
            nativeOnAttached(mNativeManagerPointer, xdevice);
        }
    }
    if (!mIsInitialized && mPendingDevices.isEmpty()) {
        nativeOnInitialized(mNativeManagerPointer, mDevices.toArray(new MidiDeviceAndroid[0]));
        mIsInitialized = true;
    }
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
@Override
public void onPortSelected(final MidiPortWrapper wrapper) {
    close();

    final MidiDeviceInfo info = wrapper.getDeviceInfo();
    if (info != null) {
        mMidiManager.openDevice(info, new MidiManager.OnDeviceOpenedListener() {

                @Override
            public void onDeviceOpened(MidiDevice device) {
                if (device == null) {
                    Log.e(MidiConstants.TAG, "could not open " + info);
                } else {
                    mOpenDevice = device;
                    mOutputPort = device.openOutputPort(wrapper.getPortIndex());
                    if (mOutputPort == null) {
                        Log.e(MidiConstants.TAG,
                                "could not open output port for " + info);
                        return;
                    }
                    mOutputPort.connect(mDispatcher);
                }
            }
        }, null);
        // Don't run the callback on the UI thread because openOutputPort might take a while.
    }
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
public void initPort() {
  Log.d("DEBUG", "initPort...");

  midiManager = (MidiManager) context.getSystemService(Context.MIDI_SERVICE);
  if (midiManager != null) {
    final MidiDeviceInfo[] infos = midiManager.getDevices();

    for (final MidiDeviceInfo info : infos) {
      final int numInputs = info.getInputPortCount();
      final int numOutputs = info.getOutputPortCount();

      if (numOutputs == 0)
        continue;

      Log.d("DEBUG", "in port num = " + numInputs);
      Log.d("DEBUG", "out port num = " + numOutputs);

      int portIndex = 0;
      for (MidiDeviceInfo.PortInfo portInfo : info.getPorts()) {
        Log.d("DEBUG", "name: " + portInfo.getName());

        String portName = portInfo.getName();

        final int pi = portIndex;
        midiManager.openDevice(info, new MidiManager.OnDeviceOpenedListener() {
          @Override
          public void onDeviceOpened(MidiDevice device) {
            if (device == null) {
              Log.d("DEBUG", "could not open device " + info);
            } else {
              Log.d("DEBUG", "a onDeviceOpend...");

              switch (pi) {
                case 0:
                  midiInputPort = device.openInputPort(numInputs - 1);

                  if (midiInputPort == null) {
                    Log.d("DEBUG", "midi input port is null...");
                  }
                  break;
                case 1:
                  midiOutputPort = device.openOutputPort(numOutputs - 1);

                  if (midiOutputPort == null) {
                    Log.d("DEBUG", "midi output port is null...");
                  }
                  break;
              }
              initializedMidi = true;
            }
          }
        }, null);

        portIndex++;
      }
    }
    //Log.d("DEBUG", "midi:" + infos.length);
  }
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
/**
 * Returns the underlying device.
 */
MidiDevice getDevice() {
    return mDevice;
}
 

import android.media.midi.MidiDevice; //导入依赖的package包/类
/**
 * @param bluetoothDevice
 * @param midiDevice
 */
public BluetoothMidiDeviceTracker(BluetoothDevice bluetoothDevice,
        MidiDevice midiDevice) {
    this.bluetoothDevice = bluetoothDevice;
    this.midiDevice = midiDevice;
}