source: tmcsimulator/trunk/src/tmcsim/cadsimulator/SoundPlayer.java @ 16

package tmcsim.cadsimulator;



import java.io.File;

import java.io.FileInputStream;

import java.util.Timer;

import java.util.TimerTask;

import java.util.Vector;

import java.util.logging.Level;

import java.util.logging.Logger;



import sun.audio.AudioPlayer;

import sun.audio.AudioStream;

import tmcsim.client.cadclientgui.data.IncidentEvent;



/**

 * SoundPlayer is used to play audio files associated with IncidentEvents that 

 * occur during a simulation.  When the SoundPlayer has been enabled audio 

 * clips are enqueued by calling the enqueueClip() method.  The audio files 

 * are played in order of receipt and when finished, the IncidentEvent is 

 * notified.  Audio playing may be disabled or enabled through the 

 * setAudioEnabled() method.  Disabling audio will cause a currently

 * playing audio clip to stop and be requeued at the front of the queue.  

 * Re-enabling the audio will then continue playing all queued clips.  The

 * deQueueAll() method is used to clear the list of audio clips that have 

 * been queued.

 *

 * @author Matthew Cechini (mcechini@calpoly.edu)

 * @version $Date: 2006/06/06 20:46:41 $ $Revision: 1.3 $

 */

public class SoundPlayer extends Thread {

    

    /** Error Logger. */

    private Logger soundLogger = Logger.getLogger("tmcsim.cadsimulator");

                                

    /** The base location that wav files are referenced from */             

    private String baseAudioDir = "";

                                

    /** The private vector of audioClips used during a simulation */

    private Vector<AudioClipInfo> enqueuedClips = null;

    

    /** The audio clip that is currently being played by the AudioPlayer. */

    private AudioClipInfo currentClip = null;

    

    /** Audio stream for playing audio files. */

    private AudioStream audioStream = null;

    

    /**

     * Flag to designate when an audio file is playing. This prevents 

     * multiple audio files from being played simultaneously. 

     * Flag is initialized to false.

     */

    private boolean audioPlaying = false;   

    

    /** Flag to designate whether audio playing is enabled.  If audio is disabled,

     *  then enquque events will be ignored.  Flag is initialized to false.

     */

    private boolean audioEnabled = false;

    

    /** Timer used to pause audio player during an audio file. */

    private Timer timer = null;

    

    /** Inner class used to contain the audio file's name and duration. */

    private class AudioClipInfo {

        String fileName;

        int duration;

        IncidentEvent theEvent;

        

        AudioClipInfo(IncidentEvent ie) {

            fileName = ie.waveFile;

            duration = ie.waveLength;   

            theEvent = ie;

        }       

                

        AudioClipInfo(String name, int dur) {

            fileName = name;

            duration = dur; 

            theEvent = null;

        }   

        

        public void wavePlayed() {

            if(theEvent != null)

                theEvent.wavePlayed();

        }   

    }

 

    /**

     * Constructor.  Establish the base file path for wav file referencing.

     *

     * @param wavFilePath Pathname for where the simulation wav files will be referenced.

     */

    public SoundPlayer(String baseFilePath) {

        

        baseAudioDir  = baseFilePath;

        audioPlaying  = false;

        audioEnabled  = true;

        timer         = new Timer();                        

        enqueuedClips = new Vector<AudioClipInfo>();

    }



    /**

     * Add a audioClipInfo object to the audioClips Vector.  The enqueued audio file will play

     * when all previously enqueued audio files have been played.  If audio is not enabled, the

     * clip will not be queued, and the incident event will be notified that the audio clip 

     * has finished playing to allow the simulation to continue.

     *

     * @param ie The Incident Event to enqueue to the current list of events.

     */

    public void enqueueClip (IncidentEvent ie) {



        if(audioEnabled) {

            synchronized(enqueuedClips)  {

                enqueuedClips.add(new AudioClipInfo(ie));

            }

        }

        else {

            ie.wavePlayed();

        }

    } 

    

    /**

     * Method called when user presses reset in simulation.  All queued events need

     * to be deQueued.

     */

    public void deQueueAll() {

        synchronized(enqueuedClips) {

            enqueuedClips.clear();

        }       

    }  

    

    /** 

     * Get the current audio enabled status.

     *

     * @return True if enabled, false if disabled.

     */

    public boolean getAudioEnabled() {

        return audioEnabled;

    }   

    

    /**

     * Set the current audio enabled status.  A false value will cause all

     * enqueue events to be ignored.  A currently playing audio file will be 

     * stopped and requeued.  All other queued events will remain in the queue.

     *

     * @param enable True if enabling, false if disabling.

     */

    public void setAudioEnabled(boolean enable) {

        

        if(!enable) {           

            timer.cancel();

            AudioPlayer.player.stop(audioStream);

            

            if(currentClip != null) {

                enqueuedClips.add(0, currentClip);

            }           

            

            audioPlaying = false;

        }

        

        audioEnabled = enable;

    }

    

        

    /**

     * Method declaration for the Thread.run() method.  While this thread is not 

     * interrupted, check if there are enqueued audio files.  If so, remove the 

     * first one(FIFO) create an AudioClip object, and play the audio file.

     * A timer tis then started for the duration of the audio file.  When the

     * timer expires the audioPlaying flag is reset to false and the corresponding

     * incident event is notified of the audio file's completion.

     */

    public void run() {

        AudioClipInfo theClip = null;

        

        while(!isInterrupted()) {

            

            synchronized(enqueuedClips) {

                if(enqueuedClips.size() > 0 && !audioPlaying && audioEnabled)

                    theClip = enqueuedClips.remove(0);                  

            }

                

            //if nothing to play, wait a second

            if(theClip == null) {

                try { Thread.sleep(1000);} catch (Exception e) {}

            }

            else {

                        

                try{

                    

                    if(theClip.duration > 0) {              

                        

                        File audioFile = new File(baseAudioDir + theClip.fileName);

                        

                        if(audioFile.exists()) {

                            audioStream = new AudioStream (new FileInputStream(audioFile));      

                            AudioPlayer.player.start(audioStream);  

                        }

                        else {

                            throw new Exception();

                        } 

                    }

                    

                    currentClip  = theClip;                                             

                    audioPlaying = true;

                    

                    timer = new Timer();

                    timer.schedule(new TimerTask () {

                        public void run() {

                            clipPlayed();

                            audioPlaying = false;                       

                        }

                    }, theClip.duration * 1000);

                    

                    theClip = null;                     

                } 

                catch (Exception e) {

                    soundLogger.logp(Level.WARNING, "SoundPlayer", "run", 

                            "Unable to play audio file: " + baseAudioDir + theClip.fileName, e);

    

                    theClip.theEvent.wavePlayed();

                    theClip = null;

                    timer.cancel();

                }   

            }                               

        }                       

    }

    

        

    /**

     * Called when audio file finishes playing.  Notifies the corresponding 

     * Incident Event that its audio file has finished playing.

     */

    private void clipPlayed() {

        currentClip.wavePlayed();

    }  

}