I want to play sounds one after another, but I keep them waiting until the first one is done. How should I do it?
I am currently making a simple Morse code translator, and I want my code to emit a long beep for "-" and a short beep for ".", And of course this must be done one after the other. But my program is now playing all at once. What am I doing wrong?
I tried adding onCompletionListener, but Netbeans 8.1 gives error and cannot solve the problem.
//Play the morse code
public void playButton(ActionEvent event){
String morse = mcTextField.getText();
char[] charArray = morse.toCharArray();
for(int x = 0; x<charArray.length; x++){
if(charArray[x] == '.'){
playBeep(shortBeep);
}
else if(charArray[x] == '-'){
playBeep(longBeep);
}
else{
sleep(500);
}
sleep(1000);
}
}
private void playBeep(String name){
String musicFile = name;
Media sound = new Media(new File(musicFile).toURI().toString());
MediaPlayer mediaPlayer = new MediaPlayer(sound);
mediaPlayer.play();
sleep(1000);
}
private void sleep(int duration){
try{
Thread.sleep(duration);
}catch(Exception e){
System.out.println("Did not work."+e);
}
}
source to share
This uses the Java Sound API , but the basic idea should be workable for most audio libraries if you provide an "end of play".
All it does is puts the sequence you want to play in the queue, it plays the next tone, waiting for completion, and plays the next one until there are no more tones in the queue.
Since it AudioClip
plays its own stream in it, another one is used for this Thread
so that this example can "wait" for the sequence to be completely played. If you do it from within the UI framework, you can get away with no additional overhead.
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.LineEvent;
import javax.sound.sampled.LineListener;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.UnsupportedAudioFileException;
public class Test {
public static void main(String[] args) throws InterruptedException {
try {
new Test();
} catch (UnsupportedAudioFileException | IOException | LineUnavailableException ex) {
ex.printStackTrace();
}
}
public Test() throws UnsupportedAudioFileException, IOException, LineUnavailableException {
Sound longBeep = new Sound(new File(...));
Sound shortBeep = new Sound(new File(...));
List<Sound> message = new ArrayList<Sound>(9);
message.add(shortBeep);
message.add(shortBeep);
message.add(shortBeep);
message.add(longBeep);
message.add(longBeep);
message.add(longBeep);
message.add(shortBeep);
message.add(shortBeep);
message.add(shortBeep);
play(message);
}
public void play(List<Sound> message) {
try {
List<Sound> queue = new ArrayList<>(message);
Transmit transmit = new Transmit(message);
Thread thread = new Thread(transmit);
thread.start();
transmit.waitFor();
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
public class Transmit implements Runnable {
private List<Sound> queue;
private ReentrantLock lock;
private Condition playCondition;
public Transmit(List<Sound> message) {
this.queue = new ArrayList<>(message);
lock = new ReentrantLock();
playCondition = lock.newCondition();
}
@Override
public void run() {
playNext();
}
public void waitFor() throws InterruptedException {
lock.lock();
if (!queue.isEmpty()) {
try {
playCondition.await();
} finally {
lock.unlock();
}
} else {
lock.unlock();
}
}
protected void playNext() {
if (queue.size() > 0) {
lock.lock();
try {
System.out.println("Play Next");
Sound sound = queue.remove(0);
sound.addLineListener(new LineListener() {
@Override
public void update(LineEvent event) {
if (event.getType().equals(LineEvent.Type.STOP)) {
sound.removeLineListener(this);
System.out.println("Audio Completed");
playNext();
}
}
});
sound.play();
} finally {
lock.unlock();
}
} else {
lock.lock();
try {
playCondition.signalAll();
} finally {
lock.unlock();
}
}
}
}
public class Sound {
private Clip audio;
public Sound(AudioInputStream audioInputStream) throws LineUnavailableException, IOException {
audio = AudioSystem.getClip();
audio.open(audioInputStream);
}
public Sound(File file) throws UnsupportedAudioFileException, IOException, LineUnavailableException {
this(AudioSystem.getAudioInputStream(file));
}
public Sound(URL url) throws UnsupportedAudioFileException, IOException, LineUnavailableException {
this(AudioSystem.getAudioInputStream(url));
}
public Sound(InputStream stream) throws UnsupportedAudioFileException, IOException, LineUnavailableException {
this(AudioSystem.getAudioInputStream(stream));
}
public void close() {
Objects.requireNonNull(audio, "Audio Clip has not been initalised");
audio.close();
}
public void play() {
Objects.requireNonNull(audio, "Audio Clip has not been initalised");
audio.setFramePosition(0);
audio.start();
}
public void addLineListener(LineListener listener) {
Objects.requireNonNull(audio, "Audio Clip has not been initalised");
audio.addLineListener(listener);
}
public void removeLineListener(LineListener listener) {
Objects.requireNonNull(audio, "Audio Clip has not been initalised");
audio.removeLineListener(listener);
}
}
}
If you want to know when the sequence is complete without making it difficult to use the method waitFor
, you can easily add an observer to the class Transmit
that generates the "completed sequence" ", but I'll leave that for you to implement.
source to share