ApplicationTaskWorker.java

/* ApplicationTaskWorker.java created 2007-10-18
 *
 */

package org.signalml.app.task;

import java.util.List;

import javax.swing.SwingUtilities;
import javax.swing.SwingWorker;
import javax.swing.event.EventListenerList;

import org.apache.log4j.Logger;
import org.signalml.app.view.common.dialogs.PleaseWaitDialog;
import org.signalml.task.Task;
import org.signalml.task.TaskEvent;
import org.signalml.task.TaskEventListener;
import org.signalml.task.TaskResult;
import org.signalml.task.TaskStatus;

/** ApplicationTaskWorker
 *
 *
 * @author Michal Dobaczewski © 2007-2008 CC Otwarte Systemy Komputerowe Sp. z o.o.
 */
public class ApplicationTaskWorker extends SwingWorker<TaskResult, TaskEvent> implements TaskEventListener {

	protected static final Logger logger = Logger.getLogger(ApplicationTaskWorker.class);

	private Task task;

	private EventListenerList listenerList = new EventListenerList();
	private PleaseWaitDialog pleaseWaitDialog = null;

	public ApplicationTaskWorker(Task task) {
		super();
		this.task = task;
		task.addTaskEventListener(this);
	}

	public Task getTask() {
		return task;
	}

	public void destroy() {
		task.removeTaskEventListener(this);
	}

	@Override
	protected void done() {
		if (pleaseWaitDialog != null) {
			pleaseWaitDialog.releaseIfOwnedBy(this);
		}
	}

	@Override
	protected void process(List<TaskEvent> chunks) {
		for (TaskEvent ev : chunks) {
			fireTaskEvent(ev);
		}
	}

	@Override
	protected TaskResult doInBackground() throws Exception {

		TaskStatus status;

		logger.debug("Entering do if possible");
		task.doIfPossible();
		logger.debug("Exited do if possible");

		if (isCancelled()) {
			logger.debug("Worker is cancelled, exiting");
			return null;
		}

		synchronized (task) {

			status = task.getStatus();
			logger.debug("Task status is [" + status + "]");
			if (status.isResultAvailable()) {
				logger.debug("Worker returning with result");
				return task.getResult();
			}

		}

		logger.debug("Worker returning with null");

		return null;

	}

	@Override
	public void taskAborted(TaskEvent ev) {
		// ensure the worker relays the last possible event after it has stopped
		// (abort of a suspended task)
		if (isDone() && SwingUtilities.isEventDispatchThread()) {
			fireTaskEvent(ev);
		}
		publish(ev);
	}

	@Override
	public void taskFinished(TaskEvent ev) {
		publish(ev);
	}

	@Override
	public void taskResumed(TaskEvent ev) {
		publish(ev);
	}

	@Override
	public void taskStarted(TaskEvent ev) {
		publish(ev);
	}

	@Override
	public void taskSuspended(TaskEvent ev) {
		publish(ev);
	}

	@Override
	public void taskRequestChanged(TaskEvent ev) {
		publish(ev);
	}

	@Override
	public void taskMessageSet(TaskEvent ev) {
		publish(ev);
	}

	@Override
	public void taskTickerUpdated(TaskEvent ev) {
		publish(ev);
	}

	public void addTaskEventListener(TaskEventListener listener) {
		listenerList.add(TaskEventListener.class, listener);
	}

	public void removeTaskEventListener(TaskEventListener listener) {
		listenerList.remove(TaskEventListener.class, listener);
	}

	protected void fireTaskEvent(TaskEvent ev) {
		Object[] listeners = listenerList.getListenerList();
		for (int i = listeners.length-2; i>=0; i-=2) {
			if (listeners[i]==TaskEventListener.class) {
				switch (ev.getType()) {

				case TASK_STARTED :
					((TaskEventListener)listeners[i+1]).taskStarted(ev);
					break;
				case TASK_SUSPENDED :
					((TaskEventListener)listeners[i+1]).taskSuspended(ev);
					break;
				case TASK_RESUMED :
					((TaskEventListener)listeners[i+1]).taskResumed(ev);
					break;
				case TASK_ABORTED :
					((TaskEventListener)listeners[i+1]).taskAborted(ev);
					break;
				case TASK_FINISHED :
					((TaskEventListener)listeners[i+1]).taskFinished(ev);
					break;
				case TASK_REQUEST_CHANGED :
					((TaskEventListener)listeners[i+1]).taskRequestChanged(ev);
					break;
				case TASK_MESSAGE_SET :
					((TaskEventListener)listeners[i+1]).taskMessageSet(ev);
					break;
				case TASK_TICKER_UPDATED :
					((TaskEventListener)listeners[i+1]).taskTickerUpdated(ev);
					break;
				default :
					logger.error("Unsupported event type [" + ev.getType() + "]");
					break;

				}

			}
		}

	}

	public PleaseWaitDialog getPleaseWaitDialog() {
		return pleaseWaitDialog;
	}

	public void setPleaseWaitDialog(PleaseWaitDialog pleaseWaitDialog) {
		this.pleaseWaitDialog = pleaseWaitDialog;
	}

}