medialist.java

J2ME MIDP_Example_Applications

// Copyright 2002 Nokia Corporation. 
// 
// THIS SOURCE CODE IS PROVIDED 'AS IS', WITH NO WARRANTIES WHATSOEVER, 
// EXPRESS OR IMPLIED, INCLUDING ANY WARRANTY OF MERCHANTABILITY, FITNESS 
// FOR ANY PARTICULAR PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE 
// OR TRADE PRACTICE, RELATING TO THE SOURCE CODE OR ANY WARRANTY OTHERWISE 
// ARISING OUT OF ANY PROPOSAL, SPECIFICATION, OR SAMPLE AND WITH NO 
// OBLIGATION OF NOKIA TO PROVIDE THE LICENSEE WITH ANY MAINTENANCE OR 
// SUPPORT. FURTHERMORE, NOKIA MAKES NO WARRANTY THAT EXERCISE OF THE 
// RIGHTS GRANTED HEREUNDER DOES NOT INFRINGE OR MAY NOT CAUSE INFRINGEMENT 
// OF ANY PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OWNED OR CONTROLLED 
// BY THIRD PARTIES 
// 
// Furthermore, information provided in this source code is preliminary, 
// and may be changed substantially prior to final release. Nokia Corporation 
// retains the right to make changes to this source code at 
// any time, without notice. This source code is provided for informational 
// purposes only. 
// 
// Nokia and Nokia Connecting People are registered trademarks of Nokia
// Corporation.
// Java and all Java-based marks are trademarks or registered trademarks of
// Sun Microsystems, Inc.
// Other product and company names mentioned herein may be trademarks or
// trade names of their respective owners.
// 
// A non-exclusive, non-transferable, worldwide, limited license is hereby 
// granted to the Licensee to download, print, reproduce and modify the 
// source code. The licensee has the right to market, sell, distribute and 
// make available the source code in original or modified form only when 
// incorporated into the programs developed by the Licensee. No other 
// license, express or implied, by estoppel or otherwise, to any other 
// intellectual property rights is granted herein.

// unnamed package

import javax.microedition.lcdui.*;
import javax.microedition.media.*;
import javax.microedition.media.control.*;
import java.io.*;


public class MediaList
    extends List
    implements CommandListener, PlayerListener
{
    private final MediaSamplerMIDlet midlet;
    private final String wavFile;
    private final String midiFile;
    private final String amrFile;

    private final Command playCommand;
    private final Command stopCommand;
    private final Command exitCommand;

    private Player player;

    private boolean playing = false;


    MediaList(MediaSamplerMIDlet midlet,
              String amrFile,
              String wavFile,
              String midiFile)
    {
        super("Media Sampler", IMPLICIT);

        this.midlet = midlet;
        this.amrFile = amrFile;
        this.wavFile = wavFile;
        this.midiFile = midiFile;

        append("PlayTone", null);
        append("ToneControl", null);
        append("AMR", null);
        append("WAV", null);
        append("MIDI", null);
        append("Video", null);

        playCommand = new Command("Play", Command.ITEM, 2);
        stopCommand = new Command("Stop", Command.ITEM, 2);
        exitCommand = new Command("Exit", Command.EXIT, 1);
        addCommand(playCommand);
        addCommand(exitCommand);
        setCommandListener(this);
    }


    public void commandAction(Command cmd, Displayable disp)
    {
        if ((cmd == playCommand) ||
            ((cmd == List.SELECT_COMMAND) && !playing))
        {
            int index = getSelectedIndex();
            if (index != -1)  // -1 means nothing selected
            {
                String selected = getString(index);
                if (selected.equals("PlayTone"))
                {
                    playTone();
                }
                else if (selected.equals("ToneControl"))
                {
                    playToneControl();
                }
                else if (selected.equals("AMR"))
                {
                    play(amrFile, "audio/AMR");
                }
                else if (selected.equals("WAV"))
                {
                    play(wavFile, "audio/x-wav");
                }
                else if (selected.equals("MIDI"))
                {
                    play(midiFile, "audio/midi");
                }
                else if (selected.equals("Video"))
                {
                    midlet.listSelectVideo();
                }
            }
        }
        else if ((cmd == stopCommand) ||
                 ((cmd == List.SELECT_COMMAND) && playing))
        {
            stop();
        }
        else if (cmd == exitCommand)
        {
            midlet.listExit();
        }
    }


    void stop()
    {
        if (player != null)
        {
            player.close();
        }
    }


    private void playTone()
    {
        try
        {
            Manager.playTone(ToneControl.C4, 500, 100);
        }
        catch (MediaException me)
        {
            midlet.alertError("MediaException: " + me.getMessage());
        }
    }


    private void playToneControl()
    {
        byte[] sequence =
        {
            ToneControl.VERSION, 1,
            ToneControl.TEMPO, 30,     // times 4 = 120 beats-per-minute
            ToneControl.C4, 16,
            ToneControl.C4 + 2, 16,    // D4
            ToneControl.C4 + 4, 16,    // E4
            ToneControl.C4 + 5, 16,    // F4   (note E# does not exist)
            ToneControl.C4 + 7, 16,    // G4
            ToneControl.C4 + 9, 16,    // A4
            ToneControl.C4 + 11, 16,   // B4
            ToneControl.C4 + 9, 8,     // A4
            ToneControl.C4 + 7, 8,     // G4
            ToneControl.C4 + 5, 8,     // F4   (note E# does not exist)
            ToneControl.C4 + 4, 8,     // E4
            ToneControl.C4 + 2, 8,     // D4
            ToneControl.C4, 8,
        };
        try
        {
            player = Manager.createPlayer(Manager.TONE_DEVICE_LOCATOR);
            player.addPlayerListener(this);
            player.realize();
            ToneControl tc = (ToneControl)(player.getControl("ToneControl"));
            tc.setSequence(sequence);
            player.start();
            playingStarted();
        }
        catch (IOException ioe)
        {
            discardPlayer();
            midlet.alertError("IOException: " + ioe.getMessage());
        }
        catch (MediaException me)
        {
            discardPlayer();
            midlet.alertError("MediaException: " + me.getMessage());
        }
        catch (SecurityException se)
        {
            discardPlayer();
            midlet.alertError("SecurityException: " + se.getMessage());
        }
    }


    // Called in case of exception to make sure invalid players are closed
    private void discardPlayer()
    {
        if (player != null)
        {
            player.close();
            player = null;
        }
    }


    private void play(String file, String type)
    {
        if (file == null)
        {
            midlet.alertError("No file specified for type " + type);
        }
        else
        {
            try
            {
                InputStream is = getClass().getResourceAsStream(file);
                player = Manager.createPlayer(is, type);
                player.addPlayerListener(this);
                player.realize();
                player.start();
                playingStarted();
            }
            catch (IOException ioe)
            {
                discardPlayer();
                midlet.alertError("IOException: " + ioe.getMessage());
            }
            catch (MediaException me)
            {
                discardPlayer();
                midlet.alertError("MediaException: " + me.getMessage());
            }
            catch (SecurityException se)
            {
                discardPlayer();
                midlet.alertError("SecurityException: " + se.getMessage());
            }
        }
    }


    public void playerUpdate(final Player p,
                             final String event,
                             final Object eventData)
    {
        // queue a call to updateEvent in the user interface event queue
        Display display = midlet.getDisplay();
        display.callSerially(new Runnable() {
            public void run()
            {
                MediaList.this.updateEvent(p, event, eventData);
            }
        });
    }


    private void updateEvent(Player p, String event, Object eventData)
    {
        if (event == END_OF_MEDIA)
        {
            p.close();
        }
        else if (event == CLOSED)
        {
            player = null;
            playingStopped();
        }
    }


    private void playingStarted()
    {
        removeCommand(playCommand);
        addCommand(stopCommand);
        playing = true;
    }


    private void playingStopped()
    {
        removeCommand(stopCommand);
        addCommand(playCommand);
        playing = false;
    }
}