/*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* The Original Code is the Kowari Metadata Store.
*
* The Initial Developer of the Original Code is Plugged In Software Pty
* Ltd (http://www.pisoftware.com, mailto:info@pisoftware.com). Portions
* created by Plugged In Software Pty Ltd are Copyright (C) 2001,2002
* Plugged In Software Pty Ltd. All Rights Reserved.
*
* Contributor(s): N/A.
*
* [NOTE: The text of this Exhibit A may differ slightly from the text
* of the notices in the Source Code files of the Original Code. You
* should use the text of this Exhibit A rather than the text found in the
* Original Code Source Code for Your Modifications.]
*
*/
package org.mulgara.demo.mp3.swing.results;
// Java 2 standard packages
import javax.swing.*;
import java.util.*;
import java.awt.event.*;
// Logging
import org.apache.log4j.Logger;
// JRDF
import org.jrdf.graph.*;
// Local packages
import org.mulgara.demo.mp3.*;
import org.mulgara.demo.mp3.playback.*;
import org.mulgara.demo.mp3.swing.*;
import org.mulgara.demo.mp3.swing.widgets.*;
/**
* Panel used to play Mp3's.
*
* @created 2004-12-07
*
* @author <a href="mailto:robert.turner@tucanatech.com">Robert Turner</a>
*
* @version $Revision: 1.3 $
*
* @modified $Date: 2005/01/05 04:58:09 $
*
* @maintenanceAuthor $Author: newmana $
*
* @company <A href="mailto:info@PIsoftware.com">Plugged In Software</A>
*
* @copyright ©2001 <a href="http://www.pisoftware.com/">Plugged In
* Software Pty Ltd</a>
*
* @licence <a href="{@docRoot}/../../LICENCE">Mozilla Public License v1.1</a>
*/
public class Mp3PlayerPanel extends JPanel {
/**
* Logger. This is named after the class.
*/
private final static Logger log = Logger.getLogger(Mp3PlayerPanel.class.
getName());
/** Button for playing mp3s */
private IconButton playButton = null;
/** Button for pausing current mp3s */
private IconButton pauseButton = null;
/** Button for stopping the current mp3 */
private IconButton stopButton = null;
/** Button for skipping the currently playing Mp3 */
private IconButton skipButton = null;
/** Icon used for playing a Mp3File */
private Icon playIcon = null;
/** Icon used for pausing playback of an Mp3File */
private Icon pauseIcon = null;
/** Icon used for stopping the playback of an Mp3File */
private Icon stopIcon = null;
/** Icon used for skipping the playback of the currently playing Mp3File */
private Icon skipIcon = null;
/** Used to play list shuffled or sorted */
private JCheckBox shuffleCheckBox = null;
/** Flag used to sort/shuffle the play list */
private boolean shuffle = false;
/** Used to monitor playback */
private PlaybackThreadListener listener = null;
/** List of PlaybackThreadListeners that are also notified of events */
private List playbackListeners = null;
/** Plays the mp3 Files */
private Mp3Player player = null;
/** List of Mp3s to play */
private List playList = null;
/**
* Default constructor
*
* @throws Exception
*/
public Mp3PlayerPanel() throws Exception {
playbackListeners = new ArrayList();
setup();
}
/**
* Initializes and sets up components.
* @throws Exception
*/
private void setup() throws Exception {
//instantiate
playButton = new IconButton(getPlayIcon());
pauseButton = new IconButton(getPauseIcon());
stopButton = new IconButton(getStopIcon());
skipButton = new IconButton(getSkipIcon());
shuffleCheckBox = new JCheckBox("Shuffle");
player = (player == null) ? newMp3Player() : player;
//initialize
shuffleCheckBox.setSelected(shuffle);
addListeners();
updateButtons();
//add
add(getPlaybackPanel());
add(getSortPanel());
}
/**
* Returns a panel containing the playback buttons.
* @return JPanel
*/
private JPanel getPlaybackPanel() {
JPanel panel = new JPanel();
panel.add(playButton);
panel.add(pauseButton);
panel.add(stopButton);
panel.add(skipButton);
return panel;
}
/**
* Returns a panel containing buttons for sorting/shuffling the playlist.
* @return JPanel
*/
private JPanel getSortPanel() {
JPanel panel = new JPanel();
panel.add(shuffleCheckBox);
return panel;
}
/**
* Determines if state of the Mp3Player and initialies buttons.
* @throws IllegalStateException
*/
private void updateButtons() throws IllegalStateException {
int state = getMp3Player().getState();
switch (state) {
case (Mp3Player.PLAYING):
playButton.setEnabled(false);
pauseButton.setEnabled(true);
skipButton.setEnabled(true);
stopButton.setEnabled(true);
break;
case (Mp3Player.PAUSED):
playButton.setEnabled(true);
pauseButton.setEnabled(false);
stopButton.setEnabled(true);
skipButton.setEnabled(true);
break;
case (Mp3Player.STOPPED):
playButton.setEnabled(true);
pauseButton.setEnabled(false);
skipButton.setEnabled(false);
stopButton.setEnabled(false);
break;
default:
throw new IllegalStateException("Unknown Mp3Player state.");
}
}
/**
* Adds Listeners/Actions to the buttons.
* @throws IllegalStateException
*/
private void addListeners() throws IllegalStateException {
if ((playButton == null)
|| (stopButton == null)) {
throw new IllegalStateException("Buttons do not exist.");
}
playButton.addActionListener(new ActionListener() {
/** Plays, Pauses or Resumes the file depending on player state.
* @param e ActionEvent
*/
public void actionPerformed(ActionEvent e) {
try {
Mp3Player player = getMp3Player();
if (player.getState() == Mp3Player.STOPPED) {
player.playFiles(getPlayList());
}
else if (player.getState() == Mp3Player.PAUSED) {
player.resumePlayback();
}
}
catch (Exception exception) {
ExceptionHandler.handleException(exception);
}
}
});
pauseButton.addActionListener(new ActionListener() {
/** calls pause
* @param e ActionEvent
*/
public void actionPerformed(ActionEvent e) {
try {
Mp3Player player = getMp3Player();
player.pausePlayback();
}
catch (Exception exception) {
ExceptionHandler.handleException(exception);
}
}
});
stopButton.addActionListener(new ActionListener() {
/** calls Stop
* @param e ActionEvent
*/
public void actionPerformed(ActionEvent e) {
try {
Mp3Player player = getMp3Player();
player.stopPlayback();
}
catch (Exception exception) {
ExceptionHandler.handleException(exception);
}
}
});
skipButton.addActionListener(new ActionListener() {
/** calls Skip
* @param e ActionEvent
*/
public void actionPerformed(ActionEvent e) {
try {
Mp3Player player = getMp3Player();
player.skipTrack();
}
catch (Exception exception) {
ExceptionHandler.handleException(exception);
}
}
});
shuffleCheckBox.addActionListener(new ActionListener() {
/** updates shuffle flag
* @param e ActionEvent
*/
public void actionPerformed(ActionEvent e) {
try {
shuffle = shuffleCheckBox.isSelected();
if ((playList != null)
&& (playList.size() > 0)) {
setPlayList(playList.iterator());
//playback must be restarted
int state = getMp3Player().getState();
getMp3Player().stopPlayback();
if (state == Mp3Player.PLAYING) {
getMp3Player().playFiles(getPlayList());
}
}
} catch (Exception exception) {
ExceptionHandler.handleException(exception);
}
}
});
}
/**
* Closes any existing player and creates a new one.
* @throws Exception
* @return Mp3Player
*/
private Mp3Player newMp3Player() throws Exception {
if (player != null) {
player.close();
}
player = new Mp3Player();
player.setPlaybackListener(getPlaybackListener());
return player;
}
/**
* Returns the current Mp3Player.
* @throws IllegalStateException
* @return Mp3Player
*/
private Mp3Player getMp3Player() throws IllegalStateException {
if (player == null) {
throw new IllegalStateException("Mp3Player does not exist.");
}
return player;
}
/**
* Sets the List of Mp3s to be played.
*
* @param playIter Iterator
* @throws IllegalArgumentException
*/
public void setPlayList(Iterator playIter) throws IllegalArgumentException {
if (playIter == null) {
throw new IllegalArgumentException("'playList' is null");
}
try {
playList = new ArrayList();
Mp3File current = null;
while (playIter.hasNext()) {
current = (Mp3File) playIter.next();
playList.add(current);
}
//should the list be shuffled?
if (shuffle) {
Collections.shuffle(playList);
}
else {
Collections.sort(playList);
}
}
catch (ClassCastException castException) {
throw new IllegalArgumentException(
"Iterator should only contain Mp3Files");
}
}
/**
* Adds the Listener to the List of listeners that are notified of events.
* @param listener PlaybackThreadListener
* @throws IllegalArgumentException
*/
public void addPlaybackListener(PlaybackThreadListener listener) throws
IllegalArgumentException {
if (listener == null) {
throw new IllegalArgumentException("PlaybackThreadListener is null");
}
playbackListeners.add(listener);
}
/**
* Returns a listener to monitor playback.
* @return PlaybackThreadListener
*/
private PlaybackThreadListener getPlaybackListener() {
if (listener == null) {
listener = new PlaybackThreadListener() {
/** @param t Throwable */
public void exceptionOccurred(Throwable t) {
playbackExceptionOccurred(t);
}
/** @param resource URIReference */
public void playbackStarted(URIReference resource) {
playbackStartedOccurred(resource);
}
/** Indicates that playback has finished */
public void playbackComplete() {
playbackCompleteOccurred();
}
/** Indicates that playback has been paused */
public void playbackPaused() {
playbackPausedOccurred();
}
/** Indicates that playback has resumed */
public void playbackResumed() {
playbackResumedOccurred();
}
};
}
return listener;
}
/**
* Obtains all Mp3 to be played.
* @throws IllegalStateException
* @return Iterator
*/
private Iterator getPlayList() throws IllegalStateException {
if (playList == null) {
throw new IllegalStateException("No Mp3(s) to play.");
}
//copy mp3 Iterator
return playList.iterator();
}
/**
* Closes the underlying player and releases resources.
* @throws Exception
*/
public void close() throws Exception {
if (player != null) {
player.close();
}
}
/**
* Notify listeners of the exception.
* @param t Throwable
*/
public void playbackExceptionOccurred(Throwable t) {
Iterator iter = playbackListeners.iterator();
while (iter.hasNext()) {
((PlaybackThreadListener) iter.next()).exceptionOccurred(t);
}
}
/**
* Update play Button and Notify listeners of the event.
* @param resource URIReference
*/
public void playbackStartedOccurred(URIReference resource) {
updateButtons();
Iterator iter = playbackListeners.iterator();
while (iter.hasNext()) {
((PlaybackThreadListener) iter.next()).playbackStarted(resource);
}
}
/**
* Update play Button and Notify listeners of the event.
*/
public void playbackCompleteOccurred() {
updateButtons();
Iterator iter = playbackListeners.iterator();
while (iter.hasNext()) {
((PlaybackThreadListener) iter.next()).playbackComplete();
}
}
/**
* Update play Button and Notify listeners of the event.
*/
public void playbackPausedOccurred() {
updateButtons();
Iterator iter = playbackListeners.iterator();
while (iter.hasNext()) {
((PlaybackThreadListener) iter.next()).playbackPaused();
}
}
/**
* Update play Button and Notify listeners of the event.
*/
public void playbackResumedOccurred() {
updateButtons();
Iterator iter = playbackListeners.iterator();
while (iter.hasNext()) {
((PlaybackThreadListener) iter.next()).playbackResumed();
}
}
/**
* Returns the play Icon
* @return Icon
*/
private Icon getPlayIcon() {
if (playIcon == null) {
playIcon = IconLoader.getIcon(IconLoader.PLAY_16);
}
return playIcon;
}
/**
* Returns the pause Icon
* @return Icon
*/
private Icon getPauseIcon() {
if (pauseIcon == null) {
pauseIcon = IconLoader.getIcon(IconLoader.PAUSE_16);
}
return pauseIcon;
}
/**
* Returns the stop Icon
* @return Icon
*/
private Icon getStopIcon() {
if (stopIcon == null) {
stopIcon = IconLoader.getIcon(IconLoader.STOP_16);
}
return stopIcon;
}
/**
* Returns the skip Icon
* @return Icon
*/
private Icon getSkipIcon() {
if (skipIcon == null) {
skipIcon = IconLoader.getIcon(IconLoader.SKIP_16);
}
return skipIcon;
}
/**
* Kills any current playback
* @throws Exception
*/
public void stopPlayback() throws Exception {
getMp3Player().stopPlayback();
}
}