C:/Projekte/I2BPro/src/i2bpro/player/Player.java

package i2bpro.player;

import i2bpro.Exceptions.ErrorMsg;
import i2bpro.Exceptions.LayerException;
import i2bpro.Exceptions.PlayerException;
import i2bpro.layer.Layer;
import i2bpro.playlist.PlayList;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.media.AudioDeviceUnavailableEvent;
import javax.media.ConnectionErrorEvent;
import javax.media.ControllerErrorEvent;
import javax.media.ControllerEvent;
import javax.media.ControllerListener;
import javax.media.DataLostErrorEvent;
import javax.media.DataStarvedEvent;
import javax.media.EndOfMediaEvent;
import javax.media.InternalErrorEvent;
import javax.media.Manager;
import javax.media.NoPlayerException;
import javax.media.PrefetchCompleteEvent;
import javax.media.RealizeCompleteEvent;
import javax.media.StartEvent;
import javax.media.Time;



public final class Player implements ControllerListener
{
    //  Status des Players (0=Stop, 1=Play, 2=Pause)
    private int state = 0;

    // Lautstärkeeinstellung (0 bis 100 in Stufen von 1)
    private int volume = 70;

    // Zeigt an ob Ton an oder aus sein soll
    private boolean mute = false;

    // Player-Objekt des JMF
    private javax.media.Player player;

    // Speicherort der Audiotdaten
    private URL media = null;

    // Identifikationsnummer des Audiotitels in der Wiedergabeliste
    private int old_id = -1;

    // Enthält die Position der Unterbrechung wenn pausiert wird.
    private Time position = null;

    //  Instanz der Klasse Player
    private static Player instance = new Player();  



    private Player() {}



    public static Player getInstance() { return instance; }



    public void play(int id) throws MalformedURLException, IOException, NoPlayerException
    {
        media = LoadMedia(id);
        StartPlay(id);
    }



    private void StartPlay(int id) throws IOException, NoPlayerException
    {
     // Prüfen ob es sich bei id um den gleichen Wert wie bei old_id handelt.
     // Wenn ja, dann prüfen in welchem Status sich der Player befindet.
     if (old_id == id)
     {
            // Wenn im Status 0=stop, dann Neustart des Players
            // Wenn im Status 1=play, dann Wiedergabe von vorne beginnen
            // Wenn im Status 2=Pause, dann führe Methode PlayAfterPause aus.
            switch(state)
            {
                case 0  :  PlayerInit(); player.realize(); break;
                case 1 : player.setMediaTime(new Time(0)); break;
                case 2 : player.setMediaTime(position);
                                player.start(); state = 1; break;
            }
        } else {
            // Wenn im Status 0=stop, Ort des Audiotitels aus PlayList
            // laden und Player starten
            //
            // Wenn im Status 1=Play, Wiedergabe beenden, Player zurücksetzen,
            // Ort aus PlayList laden und Player starten.
            //
            // Wenn im Status 2=Pause, Player zurücksetzen, Ort der Audiodaten
            // aus PlayList laden, Player starten
            switch(state)
            {
                case 1 : stop(); player.close();
                case 2 : player.close();
            }
            PlayerInit();
            player.realize();
        }
        old_id = id;
    }



    private void PlayerInit() throws IOException, NoPlayerException
    {
        player = Manager.createPlayer(media);
        player.addControllerListener(this);
    }



    private URL LoadMedia(int id) throws MalformedURLException
    {
        return new File(PlayList.getInstance().getMeta(id, "media")).toURI().toURL();
    }



    public void stop()
    {
        player.stop();
        player.close();
        state = 0;
        Layer.getInstance().PlayerStopped();
    }



    public void pause()
    {
        // Für den Fall das sich der Player nicht im Status 1=Play
        // befindet wird die Aufforderung zur Pause ignoriert.
        if (state == 1)
     {
            // Position merken
            position = player.getMediaTime();
            
            // Wiedergabe stoppen
            player.stop();
            
            // Status auf 2=Pause setzen
            state = 2;

            //  Event auslösen
            Layer.getInstance().PlayerPaused();
        }
    }



    public TimeInterface getPosition()
    {
        TimeInterface pos = new TimeInterface()
        {
            public int getSeconds()
            {
                int ans = 0;
                switch (state)
                {
                    case 0: ans = 0; break;
                    case 1: ans = (int) player.getMediaTime().getSeconds(); break;
                    case 2: ans = (int)position.getSeconds(); break;
                }
                return ans;
            }

            public String getString() 
            {
                Time ans = new Time(0);
                switch (state)
                {
                    case 1: ans = player.getMediaTime(); break;
                    case 2: ans = position; break;
                }
                return Time2String(ans);
            }
        };
        return pos;
    }



    public void setPosition(int position)
    {
        // Befindet sich der Player im Status Stop, so ist der übergebene
        // Parameter position zu ignorieren. Ansonsten ist die übergebene
        //  Position im Attribute position zu speichern und der Player
        //  auf diese Position zu setzen.
     if (state == 1)
            player.setMediaTime(new Time((long)(position * 1.0E+9)));
        this.position = new Time((long)(position * 1.0E+9));
    }



    public void setVolume(int vol)
    {
        // Prüfen ob vol im definierten Bereich von 0 bis 100 liegt
     // Wenn nicht Exception auslösen, ansonsten Attribut volume auf vol
        // setzen
        vol = (vol < 0) ? 0 : vol;
        vol = (vol > 100) ? 100 : vol;
        volume = vol;
        //  Status prüfen und entsprechend reagieren
        if (state != 0)
        {
            // Berechnung des double - Wertes der Lautstärke zur Übergabe an den
            // Player, dabei Linearisierung der Kurve vornehmen.
            float value = (float)0.0;
            if (volume > 0)
                value = (float) (Math.exp(((float)(volume)/40.0)-2.5)-0.08);
                player.getGainControl().setLevel(value);
        }
        if ((volume > 0) && mute)
        {
            mute = false;
            Layer.getInstance().toggledMute();
        }
        if ((volume == 0) && (mute == false))
        {
            mute = true;
            Layer.getInstance().toggledMute();
        }
    }



    public int getVolume() { return volume; }



    public void toggleMute()
    {
        if (mute)
        {
            Layer.getInstance().setVolume(volume);
        } else {
            int vol = volume;
            Layer.getInstance().setVolume(0);
            volume = vol;
        }
    }



    public boolean isMute() { return mute; }



    public synchronized void controllerUpdate(ControllerEvent event)
    {
        if (event instanceof RealizeCompleteEvent)
        {
            //  Wenn der Player den Realize-Mode erreicht hat, dann
            //  Prefetch aufrufen
            player.prefetch();
        }
        else if (event instanceof PrefetchCompleteEvent)
        {
            //  Wenn der Player den Prefetch-Mode erreicht hat, dann
            //  start aufrufen
            player.start();
        }
        else if (event instanceof StartEvent)
        {
            //  Falls der Player im Status 0=Stop war bzw. sich noch befindet,
            //  Startposition des Audiotitels einstellen
            if (state == 0)
            {
                String[] index = PlayList.getInstance().getMeta(
                        old_id, "index").split(":");
                int seconds = Integer.parseInt(index[0],10) * 60;
                seconds += Integer.parseInt(index[1], 10);
                setPosition(seconds);
            }
            //  Wenn der Player gestartet ist, dann
            //  Status auf 1 für Play setzen und der Oberfläche
            //  das erfolgreiche starten des Abspielvorgangs mitteilen.
            if (state < 1) setVolume(volume);
            state = 1;
            Layer.getInstance().PlayerStarted();
        }
        else if (event instanceof EndOfMediaEvent)
        {
            try
            {
                //  Wenn das Ende des Abspielens gemeldet wird, dann
                //  player schließen und Status auf 0 für Stop setzen.
                //  Anschließend dem Layer dies mitteilen.
                player.close();
                state = 0;
                Layer.getInstance().PlayerStopped();
                Layer.getInstance().PlayerEndOfMedia();
            }
            catch (LayerException ex) { ErrorMsg.show(ex.getMessage()); }
            catch (MalformedURLException ex) { ErrorMsg.show(ex.getMessage()); }
            catch (IOException ex) { ErrorMsg.show(ex.getMessage()); }
            catch (NoPlayerException ex) { ErrorMsg.show(ex.getMessage()); }
        }
        //  Im folgenden werden diverse Fehlermeldungend es Players ausgewertet.
        else if (event instanceof AudioDeviceUnavailableEvent)
        {
            try { throw new PlayerException(300); }
            catch (PlayerException ex) { ErrorMsg.show(ex.getMessage()); }
        }
        else if (event instanceof ConnectionErrorEvent)
        {
            try { throw new PlayerException(301); }
            catch (PlayerException ex) { ErrorMsg.show(ex.getMessage()); }
        }
        else if (event instanceof DataLostErrorEvent)
        {
            try { throw new PlayerException(302); }
            catch (PlayerException ex) { ErrorMsg.show(ex.getMessage()); }
        }
        else if (event instanceof DataStarvedEvent)
        {
            try { throw new PlayerException(303); }
            catch (PlayerException ex) { ErrorMsg.show(ex.getMessage()); }
        }
        else if (event instanceof InternalErrorEvent)
        {
            try { throw new PlayerException(304); }
            catch (PlayerException ex) { ErrorMsg.show(ex.getMessage()); }
        }
        else if (event instanceof InternalErrorEvent)
        {
            try { throw new PlayerException(305); }
            catch (PlayerException ex) { ErrorMsg.show(ex.getMessage()); }
        }
        else if (event instanceof ControllerErrorEvent)
        {
            Pattern pattern = Pattern.compile("message=");
            Matcher matcher = pattern.matcher(event.toString());
            String err = event.toString();
            if (matcher.find())
                err = err.substring(matcher.end(), err.length()-1);
            else
                err = "";
            ErrorMsg.show("Es ist folgender Fehler aufgetreten:\n\n"+err);
        }
    }



    public TimeInterface getDuration()
    {
        TimeInterface duration = new TimeInterface()
        {
            public int getSeconds()
            {
                return (int)(player.getDuration().getSeconds());
            }

            public String getString()
            {
                return Time2String(player.getDuration());
            }
        };
        return duration;
    }



    private String Time2String(Time time)
    {
        String sTime = "";
        int seconds = (int)time.getSeconds();
        int tmp = 0;
        tmp = (int)(seconds / 3600);
        if (tmp < 10) sTime += "0";
        sTime += tmp + ":";
        seconds -= tmp * 3600;
        tmp = (int)(seconds / 60);
        if (tmp < 10) sTime += "0";
        sTime += tmp + ":";
        seconds -= tmp * 60;
        if (seconds < 10) sTime += "0";
        sTime += seconds + "";
        return sTime;
    };



    public int getState() { return state; }
}