Java MidiDeviceProvider.getDevice方法代码示例

import javax.sound.midi.spi.MidiDeviceProvider; //导入方法依赖的package包/类
/** Return a MidiDevice with a given name from a given MidiDeviceProvider.
  @param deviceName The name of the MidiDevice to be returned.
  @param provider The MidiDeviceProvider to check for MidiDevices.
  @param deviceClass The requested device type, one of Synthesizer.class,
  Sequencer.class, Receiver.class or Transmitter.class.

  @return A MidiDevice matching the requirements, or null if none is found.
 */
private static MidiDevice getNamedDevice(String deviceName,
                                         MidiDeviceProvider provider,
                                         Class deviceClass,
                                         boolean allowSynthesizer,
                                         boolean allowSequencer) {
    MidiDevice.Info[] infos = provider.getDeviceInfo();
    for (int i = 0; i < infos.length; i++) {
        if (infos[i].getName().equals(deviceName)) {
            MidiDevice device = provider.getDevice(infos[i]);
            if (isAppropriateDevice(device, deviceClass,
                                    allowSynthesizer, allowSequencer)) {
                return device;
            }
        }
    }
    return null;
}
 

import javax.sound.midi.spi.MidiDeviceProvider; //导入方法依赖的package包/类
public static void main(final String[] args) {
    final MidiDevice.Info[] infos = MidiSystem.getMidiDeviceInfo();
    for (final MidiDeviceProvider mdp : load(MidiDeviceProvider.class)) {
        for (final MidiDevice.Info info : infos) {
            if (mdp.isDeviceSupported(info)) {
                if (mdp.getDevice(info) == null) {
                    throw new RuntimeException("MidiDevice is null");
                }
            } else {
                try {
                    mdp.getDevice(info);
                    throw new RuntimeException(
                            "IllegalArgumentException expected");
                } catch (final IllegalArgumentException ignored) {
                    // expected
                }
            }
        }
    }
}
 

import javax.sound.midi.spi.MidiDeviceProvider; //导入方法依赖的package包/类
/**
 * Return a MidiDevice with a given name from a given MidiDeviceProvider.
 *
 * @param  deviceName The name of the MidiDevice to be returned
 * @param  provider The MidiDeviceProvider to check for MidiDevices
 * @param  deviceClass The requested device type, one of Synthesizer.class,
 *         Sequencer.class, Receiver.class or Transmitter.class
 * @return A MidiDevice matching the requirements, or null if none is found
 */
private static MidiDevice getNamedDevice(String deviceName,
                                         MidiDeviceProvider provider,
                                         Class<?> deviceClass,
                                         boolean allowSynthesizer,
                                         boolean allowSequencer) {
    MidiDevice.Info[] infos = provider.getDeviceInfo();
    for (int i = 0; i < infos.length; i++) {
        if (infos[i].getName().equals(deviceName)) {
            MidiDevice device = provider.getDevice(infos[i]);
            if (isAppropriateDevice(device, deviceClass,
                                    allowSynthesizer, allowSequencer)) {
                return device;
            }
        }
    }
    return null;
}
 

import javax.sound.midi.spi.MidiDeviceProvider; //导入方法依赖的package包/类
/**
 * Get the specified MIDI device.
 *
 * @param info a description of the device we're looking for
 * @return the requested MIDI device
 * @throws MidiUnavailableException if no MIDI devices are configured or found
 * @throws IllegalArgumentException if the device described by info is not found
 */
public static MidiDevice getMidiDevice(MidiDevice.Info info)
  throws MidiUnavailableException
{
  Iterator deviceProviders =
      ServiceFactory.lookupProviders(MidiDeviceProvider.class);

  if (! deviceProviders.hasNext())
    throw new MidiUnavailableException("No MIDI device providers available.");

  do
  {
    MidiDeviceProvider provider =
      (MidiDeviceProvider) deviceProviders.next();
    if (provider.isDeviceSupported(info))
      return provider.getDevice(info);
  } while (deviceProviders.hasNext());

  throw new IllegalArgumentException("MIDI device "
                                     + info + " not available.");
}
 

import javax.sound.midi.spi.MidiDeviceProvider; //导入方法依赖的package包/类
/**
  * Get the specified MIDI device.
  * 
  * @param info a description of the device we're looking for
  * @return the requested MIDI device
  * @throws MidiUnavailableException if no MIDI devices are configured or found
  * @throws IllegalArgumentException if the device described by info is not found
  */
 public static MidiDevice getMidiDevice(MidiDevice.Info info) 
   throws MidiUnavailableException
 {
   Iterator deviceProviders = 
ServiceFactory.lookupProviders(MidiDeviceProvider.class);
   
   if (! deviceProviders.hasNext())
     throw new MidiUnavailableException("No MIDI device providers available.");
   
   do
   {
     MidiDeviceProvider provider = 
       (MidiDeviceProvider) deviceProviders.next();
     if (provider.isDeviceSupported(info))
       return provider.getDevice(info);
   } while (deviceProviders.hasNext());
   
   throw new IllegalArgumentException("MIDI device " 
			       + info + " not available.");
 }
 

import javax.sound.midi.spi.MidiDeviceProvider; //导入方法依赖的package包/类
/**
 * Get the specified MIDI device.
 *
 * @param info a description of the device we're looking for
 * @return the requested MIDI device
 * @throws MidiUnavailableException if no MIDI devices are configured or found
 * @throws IllegalArgumentException if the device described by info is not found
 */
public static MidiDevice getMidiDevice(MidiDevice.Info info)
  throws MidiUnavailableException
{
  Iterator<MidiDeviceProvider> deviceProviders =
      ServiceFactory.lookupProviders(MidiDeviceProvider.class);

  if (! deviceProviders.hasNext())
    throw new MidiUnavailableException("No MIDI device providers available.");

  do
  {
    MidiDeviceProvider provider =
      (MidiDeviceProvider) deviceProviders.next();
    if (provider.isDeviceSupported(info))
      return provider.getDevice(info);
  } while (deviceProviders.hasNext());

  throw new IllegalArgumentException("MIDI device "
                                     + info + " not available.");
}
 

import javax.sound.midi.spi.MidiDeviceProvider; //导入方法依赖的package包/类
/**
 * Obtains the requested MIDI device.
 *
 * @param info a device information object representing the desired device.
 * @return the requested device
 * @throws MidiUnavailableException if the requested device is not available
 * due to resource restrictions
 * @throws IllegalArgumentException if the info object does not represent
 * a MIDI device installed on the system
 * @see #getMidiDeviceInfo
 */
public static MidiDevice getMidiDevice(MidiDevice.Info info) throws MidiUnavailableException {
    List providers = getMidiDeviceProviders();

    for(int i = 0; i < providers.size(); i++) {
        MidiDeviceProvider provider = (MidiDeviceProvider) providers.get(i);
        if (provider.isDeviceSupported(info)) {
            MidiDevice device = provider.getDevice(info);
            return device;
        }
    }
    throw new IllegalArgumentException("Requested device not installed: " + info);
}
 

import javax.sound.midi.spi.MidiDeviceProvider; //导入方法依赖的package包/类
/** From a given MidiDeviceProvider, return the first appropriate device.
    @param provider The MidiDeviceProvider to check for MidiDevices.
    @param deviceClass The requested device type, one of Synthesizer.class,
    Sequencer.class, Receiver.class or Transmitter.class.
    @return A MidiDevice is considered appropriate, or null if no
    appropriate device is found.
 */
private static MidiDevice getFirstDevice(MidiDeviceProvider provider,
                                         Class deviceClass,
                                         boolean allowSynthesizer,
                                         boolean allowSequencer) {
    MidiDevice.Info[] infos = provider.getDeviceInfo();
    for (int j = 0; j < infos.length; j++) {
        MidiDevice device = provider.getDevice(infos[j]);
        if (isAppropriateDevice(device, deviceClass,
                                allowSynthesizer, allowSequencer)) {
            return device;
        }
    }
    return null;
}
 

import javax.sound.midi.spi.MidiDeviceProvider; //导入方法依赖的package包/类
/**
 * From a given MidiDeviceProvider, return the first appropriate device.
 *
 * @param  provider The MidiDeviceProvider to check for MidiDevices
 * @param  deviceClass The requested device type, one of Synthesizer.class,
 *         Sequencer.class, Receiver.class or Transmitter.class
 * @return A MidiDevice is considered appropriate, or null if no appropriate
 *         device is found
 */
private static MidiDevice getFirstDevice(MidiDeviceProvider provider,
                                         Class<?> deviceClass,
                                         boolean allowSynthesizer,
                                         boolean allowSequencer) {
    MidiDevice.Info[] infos = provider.getDeviceInfo();
    for (int j = 0; j < infos.length; j++) {
        MidiDevice device = provider.getDevice(infos[j]);
        if (isAppropriateDevice(device, deviceClass,
                                allowSynthesizer, allowSequencer)) {
            return device;
        }
    }
    return null;
}
 

import javax.sound.midi.spi.MidiDeviceProvider; //导入方法依赖的package包/类
/**
 * Return a MidiDevice with a given name from a given MidiDeviceProvider.
 *
 * @param  deviceName The name of the MidiDevice to be returned
 * @param  provider The MidiDeviceProvider to check for MidiDevices
 * @param  deviceClass The requested device type, one of Synthesizer.class,
 *         Sequencer.class, Receiver.class or Transmitter.class
 * @param  allowSynthesizer if true, Synthesizers are considered
 *         appropriate. Otherwise only pure MidiDevices are considered
 *         appropriate (unless allowSequencer is true). This flag only has
 *         an effect for deviceClass Receiver and Transmitter. For other
 *         device classes (Sequencer and Synthesizer), this flag has no
 *         effect.
 * @param  allowSequencer if true, Sequencers are considered appropriate.
 *         Otherwise only pure MidiDevices are considered appropriate
 *         (unless allowSynthesizer is true). This flag only has an effect
 *         for deviceClass Receiver and Transmitter. For other device
 *         classes (Sequencer and Synthesizer), this flag has no effect.
 * @return A MidiDevice matching the requirements, or null if none is found
 */
private static MidiDevice getNamedDevice(String deviceName,
                                         MidiDeviceProvider provider,
                                         Class<?> deviceClass,
                                         boolean allowSynthesizer,
                                         boolean allowSequencer) {
    MidiDevice.Info[] infos = provider.getDeviceInfo();
    for (int i = 0; i < infos.length; i++) {
        if (infos[i].getName().equals(deviceName)) {
            MidiDevice device = provider.getDevice(infos[i]);
            if (isAppropriateDevice(device, deviceClass,
                                    allowSynthesizer, allowSequencer)) {
                return device;
            }
        }
    }
    return null;
}
 

import javax.sound.midi.spi.MidiDeviceProvider; //导入方法依赖的package包/类
/**
 * Obtains the requested MIDI device.
 *
 * @param  info a device information object representing the desired device
 * @return the requested device
 * @throws MidiUnavailableException if the requested device is not available
 *         due to resource restrictions
 * @throws IllegalArgumentException if the info object does not represent a
 *         MIDI device installed on the system
 * @throws NullPointerException if {@code info} is {@code null}
 * @see #getMidiDeviceInfo
 */
public static MidiDevice getMidiDevice(final MidiDevice.Info info)
        throws MidiUnavailableException {
    Objects.requireNonNull(info);
    for (final MidiDeviceProvider provider : getMidiDeviceProviders()) {
        if (provider.isDeviceSupported(info)) {
            return provider.getDevice(info);
        }
    }
    throw new IllegalArgumentException(String.format(
            "Requested device not installed: %s", info));
}
 

import javax.sound.midi.spi.MidiDeviceProvider; //导入方法依赖的package包/类
/**
 * From a given MidiDeviceProvider, return the first appropriate device.
 *
 * @param  provider The MidiDeviceProvider to check for MidiDevices
 * @param  deviceClass The requested device type, one of Synthesizer.class,
 *         Sequencer.class, Receiver.class or Transmitter.class
 * @param  allowSynthesizer if true, Synthesizers are considered
 *         appropriate. Otherwise only pure MidiDevices are considered
 *         appropriate (unless allowSequencer is true). This flag only has
 *         an effect for deviceClass Receiver and Transmitter. For other
 *         device classes (Sequencer and Synthesizer), this flag has no
 *         effect.
 * @param  allowSequencer if true, Sequencers are considered appropriate.
 *         Otherwise only pure MidiDevices are considered appropriate
 *         (unless allowSynthesizer is true). This flag only has an effect
 *         for deviceClass Receiver and Transmitter. For other device
 *         classes (Sequencer and Synthesizer), this flag has no effect.
 * @return A MidiDevice is considered appropriate, or null if no appropriate
 *         device is found
 */
private static MidiDevice getFirstDevice(MidiDeviceProvider provider,
                                         Class<?> deviceClass,
                                         boolean allowSynthesizer,
                                         boolean allowSequencer) {
    MidiDevice.Info[] infos = provider.getDeviceInfo();
    for (int j = 0; j < infos.length; j++) {
        MidiDevice device = provider.getDevice(infos[j]);
        if (isAppropriateDevice(device, deviceClass,
                                allowSynthesizer, allowSequencer)) {
            return device;
        }
    }
    return null;
}