001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: package javax.sound.midi;
019:
020: import java.util.ArrayList;
021: import java.util.List;
022:
023: import java.io.File;
024: import java.io.IOException;
025: import java.io.InputStream;
026: import java.io.OutputStream;
027: import java.net.URL;
028:
029: import javax.sound.midi.MidiDevice.Info;
030: import javax.sound.midi.spi.MidiDeviceProvider;
031: import javax.sound.midi.spi.MidiFileReader;
032: import javax.sound.midi.spi.MidiFileWriter;
033: import javax.sound.midi.spi.SoundbankReader;
034:
035: import org.apache.harmony.sound.utils.ProviderService;
036:
037: public class MidiSystem {
038: // This class has no public constructor
039: private MidiSystem() {
040: }
041:
042: //path to javax.sound.midi.spi.MidiDeviceProvider file in the jar-file
043: private final static String midiDeviceProviderPath = "META-INF/services/javax.sound.midi.spi.MidiDeviceProvider";
044:
045: //path to javax.sound.midi.spi.MidiFileReader file in the jar-file
046: private final static String midiFileReaderPath = "META-INF/services/javax.sound.midi.spi.MidiFileReader";
047:
048: //path to javax.sound.midi.spi.MidiFileWriter file in the jar-file
049: private final static String midiFileWriterPath = "META-INF/services/javax.sound.midi.spi.MidiFileWriter";
050:
051: //path to javax.sound.midi.spi.SoundbankReader file in the jar-file
052: private final static String soundbankReaderPath = "META-INF/services/javax.sound.midi.spi.SoundbankReader";
053:
054: //key to find default receiver in the sound.properties file
055: private final static String receiverName = "javax.sound.midi.Receiver";
056:
057: //key to find default sequencer in the sound.properties file
058: private final static String sequencerName = "javax.sound.midi.Sequencer";
059:
060: //key to find default synthesizer in the sound.properties file
061: private final static String synthesizerName = "javax.sound.midi.Synthesizer";
062:
063: //key to find default transmitter in the sound.properties file
064: private final static String transmitterName = "javax.sound.midi.Transmitter";
065:
066: public static MidiDevice getMidiDevice(MidiDevice.Info info)
067: throws MidiUnavailableException {
068: //FIXME
069: /*
070: * this method must to throw out MidiUnavailableException if requested device
071: * is not available
072: */
073:
074: /*
075: * obtain the list of MidiDeviceProviders
076: */
077: List<?> deviceProviders = ProviderService
078: .getProviders(midiDeviceProviderPath);
079: /*
080: * find device that describes by parameter info and return it
081: */
082: for (int i = 0; i < deviceProviders.size(); i++) {
083: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
084: .get(i)).getDeviceInfo();
085: for (Info element : deviceInfo) {
086: if (element.equals(info)) {
087: return ((MidiDeviceProvider) deviceProviders.get(i))
088: .getDevice(info);
089: }
090: }
091: }
092: /*
093: * if we can't find device with requested info, we throw out IllegalArgumentException
094: */
095: throw new IllegalArgumentException(
096: "Requested device not installed: " + info.getName());
097: }
098:
099: public static MidiDevice.Info[] getMidiDeviceInfo() {
100: /*
101: * obtain the list of MidiDeviceProviders
102: */
103: List<?> deviceProviders = ProviderService
104: .getProviders(midiDeviceProviderPath);
105: //variable to save MidiDevice.Info
106: List<MidiDevice.Info> infos = new ArrayList<MidiDevice.Info>();
107: /*
108: * look through list of providers and save info of devices
109: */
110: for (int i = 0; i < deviceProviders.size(); i++) {
111: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
112: .get(i)).getDeviceInfo();
113: for (Info element : deviceInfo) {
114: infos.add(element);
115: }
116: }
117:
118: MidiDevice.Info[] temp = new MidiDevice.Info[infos.size()];
119: return infos.toArray(temp);
120: }
121:
122: public static MidiFileFormat getMidiFileFormat(File file)
123: throws InvalidMidiDataException, IOException {
124: /*
125: * obtain the list of MidiFileReaderProviders
126: */
127: List<?> fileReaderProviders = ProviderService
128: .getProviders(midiFileReaderPath);
129: if (fileReaderProviders.size() == 0) {
130: //FIXME
131: /*
132: * I don't understand what type of exception we should throw out if we haven't
133: * appropriate providers...
134: * Maybe here is should be MidiUnavailableException
135: */
136: throw new Error(
137: "There is no MidiFileReaderProviders on your system!!!");
138: }
139: /*
140: * It's not determine what provider for this service I should to use, and so
141: * I use the first one
142: */
143: return ((MidiFileReader) fileReaderProviders.get(0))
144: .getMidiFileFormat(file);
145: }
146:
147: public static MidiFileFormat getMidiFileFormat(InputStream stream)
148: throws InvalidMidiDataException, IOException {
149: /*
150: * obtain the list of MidiFileReaderProviders
151: */
152: List<?> fileReaderProviders = ProviderService
153: .getProviders(midiFileReaderPath);
154: if (fileReaderProviders.size() == 0) {
155: //FIXME
156: /*
157: * I don't understand what type of exception we should throw out if we haven't
158: * appropriate providers...
159: * Maybe here is should be MidiUnavailableException
160: */
161: throw new Error(
162: "There is no MidiFileReaderProviders on your system!!!");
163: }
164: /*
165: * It's not determine what provider for this service I should to use, and so
166: * I use the first one
167: */
168: return ((MidiFileReader) fileReaderProviders.get(0))
169: .getMidiFileFormat(stream);
170: }
171:
172: public static MidiFileFormat getMidiFileFormat(URL url)
173: throws InvalidMidiDataException, IOException {
174: /*
175: * obtain the list of MidiFileReaderProviders
176: */
177: List<?> fileReaderProviders = ProviderService
178: .getProviders(midiFileReaderPath);
179: if (fileReaderProviders.size() == 0) {
180: //FIXME
181: /*
182: * I don't understand what type of exception we should throw out if we haven't
183: * appropriate providers...
184: * Maybe here is should be MidiUnavailableException
185: */
186: throw new Error(
187: "There is no MidiFileReaderProviders on your system!!!");
188: }
189: /*
190: * It's not determine what provider for this service I should to use, and so
191: * I use the first one
192: */
193: return ((MidiFileReader) fileReaderProviders.get(0))
194: .getMidiFileFormat(url);
195: }
196:
197: public static int[] getMidiFileTypes() {
198: /*
199: * obtain the list of MidiFileWriterProviders
200: */
201: List<?> fileWriterProviders = ProviderService
202: .getProviders(midiFileWriterPath);
203: if (fileWriterProviders.size() == 0) {
204: //FIXME
205: /*
206: * I don't understand what type of exception we should throw out if we haven't
207: * appropriate providers...
208: * Maybe here is should be MidiUnavailableException
209: */
210: throw new Error(
211: "There is no MidiFileWriterProviders on your system!!!");
212: }
213: /*
214: * It's not determine what provider for this service I should to use, and so
215: * I use the first one
216: */
217: return ((MidiFileWriter) fileWriterProviders.get(0))
218: .getMidiFileTypes();
219: }
220:
221: public static int[] getMidiFileTypes(Sequence sequence) {
222: /*
223: * obtain the list of MidiFileWriterProviders
224: */
225: List<?> fileWriterProviders = ProviderService
226: .getProviders(midiFileWriterPath);
227: if (fileWriterProviders.size() == 0) {
228: //FIXME
229: /*
230: * I don't understand what type of exception we should throw out if we haven't
231: * appropriate providers...
232: * Maybe here is should be MidiUnavailableException
233: */
234: throw new Error(
235: "There is no MidiFileWriterProviders on your system!!!");
236: }
237: /*
238: * It's not determine what provider for this service I should to use, and so
239: * I use the first one
240: */
241: return ((MidiFileWriter) fileWriterProviders.get(0))
242: .getMidiFileTypes(sequence);
243: }
244:
245: public static Receiver getReceiver()
246: throws MidiUnavailableException {
247: /*
248: * description of the default device for javax.sound.midi.Receiver
249: */
250: List<String> defaultDevice = ProviderService
251: .getDefaultDeviceDescription(receiverName);
252: /*
253: * obtain the list of MidiDeviceProviders
254: */
255: List<?> deviceProviders = ProviderService
256: .getProviders(midiDeviceProviderPath);
257: String provName;
258: int deviceNum = -1;
259: /*
260: * defaultDevice.get(0) --> provider
261: * defaultDevice.get(1) --> name
262: */
263: if (defaultDevice.size() != 0) {
264: /*
265: * obtain the provider number in the list of deviceProviders that is provider for default device
266: */
267: for (int i = 0; i < deviceProviders.size(); i++) {
268: provName = deviceProviders.get(i).toString();
269: if (provName.substring(0, provName.indexOf("@"))
270: .equals(defaultDevice.get(0))) {
271: deviceNum = i;
272: break;
273: }
274: }
275: /*
276: * the first case: find the same provider and name that describes by default device
277: */
278: if (deviceNum != -1) {
279: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
280: .get(deviceNum)).getDeviceInfo();
281: for (Info element : deviceInfo) {
282: if (element.getName().equals(defaultDevice.get(1))) {
283: try {
284: return ((MidiDeviceProvider) deviceProviders
285: .get(deviceNum)).getDevice(element)
286: .getReceiver();
287: } catch (MidiUnavailableException e) {
288: }
289: }
290: }
291: for (Info element : deviceInfo) {
292: try {
293: return ((MidiDeviceProvider) deviceProviders
294: .get(deviceNum)).getDevice(element)
295: .getReceiver();
296: } catch (MidiUnavailableException e) {
297: }
298: }
299: }
300: /*
301: * if we don't find again, find any receivers describe by name
302: */
303: for (int i = 0; i < deviceProviders.size(); i++) {
304: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
305: .get(i)).getDeviceInfo();
306: for (Info element : deviceInfo) {
307: if (element.getName().equals(defaultDevice.get(1))) {
308: try {
309: return ((MidiDeviceProvider) deviceProviders
310: .get(i)).getDevice(element)
311: .getReceiver();
312: } catch (MidiUnavailableException e) {
313: }
314: }
315: }
316: }
317: }
318: /*
319: * in the last case we look throw all providers and find any receiver
320: */
321: for (int i = 0; i < deviceProviders.size(); i++) {
322: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
323: .get(i)).getDeviceInfo();
324: for (Info element : deviceInfo) {
325: try {
326: return ((MidiDeviceProvider) deviceProviders.get(i))
327: .getDevice(element).getReceiver();
328: } catch (MidiUnavailableException e) {
329: }
330: }
331: }
332: /*
333: * if we don't find anyway, we throw out MidiUnavailableException
334: */
335: throw new MidiUnavailableException(
336: "There are no Receivers installed on your system!");
337: }
338:
339: public static Sequence getSequence(File file)
340: throws InvalidMidiDataException, IOException {
341: /*
342: * obtain the list of MidiFileReaderProviders
343: */
344: List<?> fileReaderProviders = ProviderService
345: .getProviders(midiFileReaderPath);
346: if (fileReaderProviders.size() == 0) {
347: //FIXME
348: /*
349: * I don't understand what type of exception we should throw out if we haven't
350: * appropriate providers...
351: * Maybe here is should be MidiUnavailableException
352: */
353: throw new Error(
354: "There is no MidiFileReaderProviders on your system!!!");
355: }
356: /*
357: * It's not determine what provider for this service I should to use, and so
358: * I use the first one
359: */
360: return ((MidiFileReader) fileReaderProviders.get(0))
361: .getSequence(file);
362: }
363:
364: public static Sequence getSequence(InputStream stream)
365: throws InvalidMidiDataException, IOException {
366: /*
367: * obtain the list of MidiFileReaderProviders
368: */
369: List<?> fileReaderProviders = ProviderService
370: .getProviders(midiFileReaderPath);
371: if (fileReaderProviders.size() == 0) {
372: //FIXME
373: /*
374: * I don't understand what type of exception we should throw out if we haven't
375: * appropriate providers...
376: * Maybe here is should be MidiUnavailableException
377: */
378: throw new Error(
379: "There is no MidiFileReaderProviders on your system!!!");
380: }
381: /*
382: * It's not determine what provider for this service I should to use, and so
383: * I use the first one
384: */
385: return ((MidiFileReader) fileReaderProviders.get(0))
386: .getSequence(stream);
387: }
388:
389: public static Sequence getSequence(URL url)
390: throws InvalidMidiDataException, IOException {
391: /*
392: * obtain the list of MidiFileReaderProviders
393: */
394: List<?> fileReaderProviders = ProviderService
395: .getProviders(midiFileReaderPath);
396: if (fileReaderProviders.size() == 0) {
397: //FIXME
398: /*
399: * I don't understand what type of exception we should throw out if we haven't
400: * appropriate providers...
401: * Maybe here is should be MidiUnavailableException
402: */
403: throw new Error(
404: "There is no MidiFileReaderProviders on your system!!!");
405: }
406: /*
407: * It's not determine what provider for this service I should to use, and so
408: * I use the first one
409: */
410: return ((MidiFileReader) fileReaderProviders.get(0))
411: .getSequence(url);
412: }
413:
414: public static Sequencer getSequencer()
415: throws MidiUnavailableException {
416: /*
417: * this method is equals to method MidiSystem.getSequencer(true)
418: */
419: return getSequencer(true);
420: }
421:
422: public static Sequencer getSequencer(boolean connected)
423: throws MidiUnavailableException {
424: /*
425: * description of the default device for javax.sound.midi.Sequencer
426: */
427: List<String> defaultDevice = ProviderService
428: .getDefaultDeviceDescription(sequencerName);
429: /*
430: * obtain the list of MidiDeviceProviders
431: */
432: List<?> deviceProviders = ProviderService
433: .getProviders(midiDeviceProviderPath);
434:
435: Sequencer sequencer;
436: Transmitter seqTrans;
437: Synthesizer synth;
438: Receiver recv;
439: String provName;
440: int deviceNum = -1;
441: /*
442: * defaultDevice.get(0) --> provider
443: * defaultDevice.get(1) --> name
444: */
445: if (defaultDevice.size() != 0) {
446: /*
447: * obtain the provider number in the list of deviceProviders that is provider for default device
448: */
449: for (int i = 0; i < deviceProviders.size(); i++) {
450: provName = deviceProviders.get(i).toString();
451: if (provName.substring(0, provName.indexOf("@"))
452: .equals(defaultDevice.get(0))) {
453: deviceNum = i;
454: break;
455: }
456: }
457: /*
458: * the first case: find the same provider and name that describes by default device
459: */
460: if (deviceNum != -1) {
461: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
462: .get(deviceNum)).getDeviceInfo();
463: for (Info element : deviceInfo) {
464: if (element.getName().equals(defaultDevice.get(1))) {
465: if (((MidiDeviceProvider) deviceProviders
466: .get(deviceNum)).getDevice(element) instanceof Sequencer) {
467: if (connected) {
468: sequencer = (Sequencer) ((MidiDeviceProvider) deviceProviders
469: .get(deviceNum))
470: .getDevice(element);
471: seqTrans = sequencer.getTransmitter();
472: try {
473: synth = MidiSystem.getSynthesizer();
474: recv = synth.getReceiver();
475: } catch (MidiUnavailableException e) {
476: /*
477: * if we haven't Synthesizer in the system, we use default receiver
478: */
479: recv = MidiSystem.getReceiver();
480: }
481: seqTrans.setReceiver(recv);
482: return sequencer;
483: }
484: return (Sequencer) ((MidiDeviceProvider) deviceProviders
485: .get(deviceNum)).getDevice(element);
486: }
487: }
488: }
489: for (Info element : deviceInfo) {
490: if (((MidiDeviceProvider) deviceProviders
491: .get(deviceNum)).getDevice(element) instanceof Sequencer) {
492: if (connected) {
493: sequencer = (Sequencer) ((MidiDeviceProvider) deviceProviders
494: .get(deviceNum)).getDevice(element);
495: seqTrans = sequencer.getTransmitter();
496: try {
497: synth = MidiSystem.getSynthesizer();
498: recv = synth.getReceiver();
499: } catch (MidiUnavailableException e) {
500: /*
501: * if we haven't Synthesizer in the system, we use default receiver
502: */
503: recv = MidiSystem.getReceiver();
504: }
505: seqTrans.setReceiver(recv);
506: return sequencer;
507: }
508: return (Sequencer) ((MidiDeviceProvider) deviceProviders
509: .get(deviceNum)).getDevice(element);
510: }
511: }
512: }
513: /*
514: * if we don't find again, find any receivers describe by name
515: */
516: for (int i = 0; i < deviceProviders.size(); i++) {
517: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
518: .get(i)).getDeviceInfo();
519: for (Info element : deviceInfo) {
520: if (element.getName().equals(defaultDevice.get(1))) {
521: if (((MidiDeviceProvider) deviceProviders
522: .get(i)).getDevice(element) instanceof Sequencer) {
523: if (connected) {
524: sequencer = (Sequencer) ((MidiDeviceProvider) deviceProviders
525: .get(i)).getDevice(element);
526: seqTrans = sequencer.getTransmitter();
527: try {
528: synth = MidiSystem.getSynthesizer();
529: recv = synth.getReceiver();
530: } catch (MidiUnavailableException e) {
531: /*
532: * if we haven't Synthesizer in the system, we use default receiver
533: */
534: recv = MidiSystem.getReceiver();
535: }
536: seqTrans.setReceiver(recv);
537: return sequencer;
538: }
539: return (Sequencer) ((MidiDeviceProvider) deviceProviders
540: .get(i)).getDevice(element);
541: }
542: }
543: }
544: }
545: }
546: /*
547: * in the last case we look throw all providers and find any receiver
548: */
549: for (int i = 0; i < deviceProviders.size(); i++) {
550: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
551: .get(i)).getDeviceInfo();
552: for (Info element : deviceInfo) {
553: if (((MidiDeviceProvider) deviceProviders.get(i))
554: .getDevice(element) instanceof Sequencer) {
555: if (connected) {
556: sequencer = (Sequencer) ((MidiDeviceProvider) deviceProviders
557: .get(i)).getDevice(element);
558: seqTrans = sequencer.getTransmitter();
559: try {
560: synth = MidiSystem.getSynthesizer();
561: recv = synth.getReceiver();
562: } catch (MidiUnavailableException e) {
563: /*
564: * if we haven't Synthesizer in the system, we use default receiver
565: */
566: recv = MidiSystem.getReceiver();
567: }
568: seqTrans.setReceiver(recv);
569: return sequencer;
570: }
571: return (Sequencer) ((MidiDeviceProvider) deviceProviders
572: .get(i)).getDevice(element);
573: }
574: }
575: }
576: /*
577: * if we don't find anyway, we throw out MidiUnavailableException
578: */
579: throw new MidiUnavailableException(
580: "There are no Synthesizers installed on your system!");
581: }
582:
583: public static Soundbank getSoundbank(File file)
584: throws InvalidMidiDataException, IOException {
585: /*
586: * obtain the list of SoundbankReaderProviders
587: */
588: List<?> soundbankReaderProviders = ProviderService
589: .getProviders(soundbankReaderPath);
590: if (soundbankReaderProviders.size() == 0) {
591: //FIXME
592: /*
593: * I don't understand what type of exception we should throw out if we haven't
594: * appropriate providers...
595: * Maybe here is should be MidiUnavailableException
596: */
597: throw new Error(
598: "There is no SoundbankReaderProviders on your system!!!");
599: }
600: /*
601: * It's not determine what provider for this service I should to use, and so
602: * I use the first one
603: */
604: return ((SoundbankReader) soundbankReaderProviders.get(0))
605: .getSoundbank(file);
606: }
607:
608: public static Soundbank getSoundbank(InputStream stream)
609: throws InvalidMidiDataException, IOException {
610: /*
611: * obtain the list of SoundbankReaderProviders
612: */
613: List<?> soundbankReaderProviders = ProviderService
614: .getProviders(soundbankReaderPath);
615: if (soundbankReaderProviders.size() == 0) {
616: //FIXME
617: /*
618: * I don't understand what type of exception we should throw out if we haven't
619: * appropriate providers...
620: * Maybe here is should be MidiUnavailableException
621: */
622: throw new Error(
623: "There is no SoundbankReaderProviders on your system!!!");
624: }
625: /*
626: * It's not determine what provider for this service I should to use, and so
627: * I use the first one
628: */
629: return ((SoundbankReader) soundbankReaderProviders.get(0))
630: .getSoundbank(stream);
631: }
632:
633: public static Soundbank getSoundbank(URL url)
634: throws InvalidMidiDataException, IOException {
635: /*
636: * obtain the list of SoundbankReaderProviders
637: */
638: List<?> soundbankReaderProviders = ProviderService
639: .getProviders(soundbankReaderPath);
640: if (soundbankReaderProviders.size() == 0) {
641: //FIXME
642: /*
643: * I don't understand what type of exception we should throw out if we haven't
644: * appropriate providers...
645: * Maybe here is should be MidiUnavailableException
646: */
647: throw new Error(
648: "There is no SoundbankReaderProviders on your system!!!");
649: }
650: /*
651: * It's not determine what provider for this service I should to use, and so
652: * I use the first one
653: */
654: return ((SoundbankReader) soundbankReaderProviders.get(0))
655: .getSoundbank(url);
656: }
657:
658: public static Synthesizer getSynthesizer()
659: throws MidiUnavailableException {
660: /*
661: * description of the default device for javax.sound.midi.Synthesizer
662: */
663: List<String> defaultDevice = ProviderService
664: .getDefaultDeviceDescription(synthesizerName);
665: /*
666: * obtain the list of MidiDeviceProviders
667: */
668: List<?> deviceProviders = ProviderService
669: .getProviders(midiDeviceProviderPath);
670: String provName;
671: int deviceNum = -1;
672:
673: /*
674: * defaultDevice.get(0) --> provider
675: * defaultDevice.get(1) --> name
676: */
677: if (defaultDevice.size() != 0) {
678: /*
679: * obtain the provider number in the list of deviceProviders that is provider for default device
680: */
681: for (int i = 0; i < deviceProviders.size(); i++) {
682: provName = deviceProviders.get(i).toString();
683: if (provName.substring(0, provName.indexOf("@"))
684: .equals(defaultDevice.get(0))) {
685: deviceNum = i;
686: break;
687: }
688: }
689: /*
690: * the first case: find the same provider and name that describes by default device
691: */
692: if (deviceNum != -1) {
693: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
694: .get(deviceNum)).getDeviceInfo();
695: for (Info element : deviceInfo) {
696: if (element.getName().equals(defaultDevice.get(1))) {
697: if (((MidiDeviceProvider) deviceProviders
698: .get(deviceNum)).getDevice(element) instanceof Synthesizer) {
699: return (Synthesizer) ((MidiDeviceProvider) deviceProviders
700: .get(deviceNum)).getDevice(element);
701: }
702: }
703: }
704: for (Info element : deviceInfo) {
705: if (((MidiDeviceProvider) deviceProviders
706: .get(deviceNum)).getDevice(element) instanceof Synthesizer) {
707: return (Synthesizer) ((MidiDeviceProvider) deviceProviders
708: .get(deviceNum)).getDevice(element);
709: }
710: }
711: }
712: /*
713: * if we don't find again, find any receivers describe by name
714: */
715: for (int i = 0; i < deviceProviders.size(); i++) {
716: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
717: .get(i)).getDeviceInfo();
718: for (Info element : deviceInfo) {
719: if (element.getName().equals(defaultDevice.get(1))) {
720: if (((MidiDeviceProvider) deviceProviders
721: .get(i)).getDevice(element) instanceof Synthesizer) {
722: return (Synthesizer) ((MidiDeviceProvider) deviceProviders
723: .get(i)).getDevice(element);
724: }
725: }
726: }
727: }
728: }
729: /*
730: * in the last case we look throw all providers and find any receiver
731: */
732: for (int i = 0; i < deviceProviders.size(); i++) {
733: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
734: .get(i)).getDeviceInfo();
735: for (Info element : deviceInfo) {
736: if (((MidiDeviceProvider) deviceProviders.get(i))
737: .getDevice(element) instanceof Synthesizer) {
738: return (Synthesizer) ((MidiDeviceProvider) deviceProviders
739: .get(i)).getDevice(element);
740: }
741: }
742: }
743: /*
744: * if we don't find anyway, we throw out MidiUnavailableException
745: */
746: throw new MidiUnavailableException(
747: "There are no Synthesizers installed on your system!");
748: }
749:
750: public static Transmitter getTransmitter()
751: throws MidiUnavailableException {
752: /*
753: * description of the default device for javax.sound.midi.Transmitter
754: */
755: List<String> defaultDevice = ProviderService
756: .getDefaultDeviceDescription(transmitterName);
757: /*
758: * obtain the list of MidiDeviceProviders
759: */
760: List<?> deviceProviders = ProviderService
761: .getProviders(midiDeviceProviderPath);
762: String provName;
763: int deviceNum = -1;
764: /*
765: * defaultDevice.get(0) --> provider
766: * defaultDevice.get(1) --> name
767: */
768: if (defaultDevice.size() != 0) {
769: /*
770: * obtain the provider number in the list of deviceProviders that is provider for default device
771: */
772: for (int i = 0; i < deviceProviders.size(); i++) {
773: provName = deviceProviders.get(i).toString();
774: if (provName.substring(0, provName.indexOf("@"))
775: .equals(defaultDevice.get(0))) {
776: deviceNum = i;
777: break;
778: }
779: }
780: /*
781: * the first case: find the same provider and name that describes by default device
782: */
783: if (deviceNum != -1) {
784: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
785: .get(deviceNum)).getDeviceInfo();
786: for (Info element : deviceInfo) {
787: if (element.getName().equals(defaultDevice.get(1))) {
788: try {
789: return ((MidiDeviceProvider) deviceProviders
790: .get(deviceNum)).getDevice(element)
791: .getTransmitter();
792: } catch (MidiUnavailableException e) {
793: }
794: }
795: }
796: for (Info element : deviceInfo) {
797: try {
798: return ((MidiDeviceProvider) deviceProviders
799: .get(deviceNum)).getDevice(element)
800: .getTransmitter();
801: } catch (MidiUnavailableException e) {
802: }
803: }
804: }
805: /*
806: * if we don't find again, find any receivers describe by name
807: */
808: for (int i = 0; i < deviceProviders.size(); i++) {
809: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
810: .get(i)).getDeviceInfo();
811: for (Info element : deviceInfo) {
812: if (element.getName().equals(defaultDevice.get(1))) {
813: try {
814: return ((MidiDeviceProvider) deviceProviders
815: .get(i)).getDevice(element)
816: .getTransmitter();
817: } catch (MidiUnavailableException e) {
818: }
819: }
820: }
821: }
822: }
823: /*
824: * in the last case we look throw all providers and find any receiver
825: */
826: for (int i = 0; i < deviceProviders.size(); i++) {
827: MidiDevice.Info[] deviceInfo = ((MidiDeviceProvider) deviceProviders
828: .get(i)).getDeviceInfo();
829: for (Info element : deviceInfo) {
830: try {
831: return ((MidiDeviceProvider) deviceProviders.get(i))
832: .getDevice(element).getTransmitter();
833: } catch (MidiUnavailableException e) {
834: }
835: }
836: }
837: /*
838: * if we don't find anyway, we throw out MidiUnavailableException
839: */
840: throw new MidiUnavailableException(
841: "There are no Transmitters installed on your system!");
842: }
843:
844: public static boolean isFileTypeSupported(int fileType) {
845: /*
846: * obtain the list of MidiFileWriterProviders;
847: * if we already obtain the list of providers, we don't obtain it again
848: */
849: List<?> fileWriterProviders = ProviderService
850: .getProviders(midiFileWriterPath);
851: if (fileWriterProviders.size() == 0) {
852: //FIXME
853: /*
854: * I don't understand what type of exception we should throw out if we haven't
855: * appropriate providers...
856: * Maybe here is should be MidiUnavailableException
857: */
858: throw new Error(
859: "There is no MidiFileWriterProviders on your system!!!");
860: }
861: /*
862: * It's not determine what provider for this service I should to use, and so
863: * I use the first one
864: */
865: return ((MidiFileWriter) fileWriterProviders.get(0))
866: .isFileTypeSupported(fileType);
867: }
868:
869: public static boolean isFileTypeSupported(int fileType,
870: Sequence sequence) {
871: /*
872: * obtain the list of MidiFileWriterProviders
873: */
874: List<?> fileWriterProviders = ProviderService
875: .getProviders(midiFileWriterPath);
876: if (fileWriterProviders.size() == 0) {
877: //FIXME
878: /*
879: * I don't understand what type of exception we should throw out if we haven't
880: * appropriate providers...
881: * Maybe here is should be MidiUnavailableException
882: */
883: throw new Error(
884: "There is no MidiFileWriterProviders on your system!!!");
885: }
886: /*
887: * It's not determine what provider for this service I should to use, and so
888: * I use the first one
889: */
890: return ((MidiFileWriter) fileWriterProviders.get(0))
891: .isFileTypeSupported(fileType, sequence);
892: }
893:
894: public static int write(Sequence in, int type, File out)
895: throws IOException {
896: /*
897: * obtain the list of MidiFileWriterProviders
898: */
899: List<?> fileWriterProviders = ProviderService
900: .getProviders(midiFileWriterPath);
901: if (fileWriterProviders.size() == 0) {
902: //FIXME
903: /*
904: * I don't understand what type of exception we should throw out if we haven't
905: * appropriate providers...
906: * Maybe here is should be MidiUnavailableException
907: */
908: throw new Error(
909: "There is no MidiFileWriterProviders on your system!!!");
910: }
911: /*
912: * It's not determine what provider for this service I should to use, and so
913: * I use the first one
914: */
915: return ((MidiFileWriter) fileWriterProviders.get(0)).write(in,
916: type, out);
917: }
918:
919: public static int write(Sequence in, int fileType, OutputStream out)
920: throws IOException {
921: /*
922: * obtain the list of MidiFileWriterProviders
923: */
924: List<?> fileWriterProviders = ProviderService
925: .getProviders(midiFileWriterPath);
926: if (fileWriterProviders.size() == 0) {
927: //FIXME
928: /*
929: * I don't understand what type of exception we should throw out if we haven't
930: * appropriate providers...
931: * Maybe here is should be MidiUnavailableException
932: */
933: throw new Error(
934: "There is no MidiFileWriterProviders on your system!!!");
935: }
936: /*
937: * It's not determine what provider for this service I should to use, and so
938: * I use the first one
939: */
940: return ((MidiFileWriter) fileWriterProviders.get(0)).write(in,
941: fileType, out);
942: }
943: }
|