Back to index...

	/*
	* Copyright (c) 1998, 2018, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.media.sound;

	import java.util.ArrayList;
	import java.util.List;

	import javax.sound.midi.ControllerEventListener;
	import javax.sound.midi.MetaEventListener;
	import javax.sound.midi.MetaMessage;
	import javax.sound.midi.ShortMessage;
	import javax.sound.sampled.LineEvent;
	import javax.sound.sampled.LineListener;



	/**
	* EventDispatcher. Used by various classes in the Java Sound implementation
	* to send events.
	*
	* @author David Rivas
	* @author Kara Kytle
	* @author Florian Bomers
	*/
	final class EventDispatcher implements Runnable {

	/**
	* time of inactivity until the auto closing clips
	* are closed
	*/
	private static final int AUTO_CLOSE_TIME = 5000;


	/**
	* List of events
	*/
	private final ArrayList eventQueue = new ArrayList();


	/**
	* Thread object for this EventDispatcher instance
	*/
	private Thread thread = null;


	/*
	* support for auto-closing Clips
	*/
	private final ArrayList<ClipInfo> autoClosingClips = new ArrayList<ClipInfo>();

	/*
	* support for monitoring data lines
	*/
	private final ArrayList<LineMonitor> lineMonitors = new ArrayList<LineMonitor>();

	/**
	* Approximate interval between calls to LineMonitor.checkLine
	*/
	static final int LINE_MONITOR_TIME = 400;


	/**
	* This start() method starts an event thread if one is not already active.
	*/
	synchronized void start() {

	if(thread == null) {
	thread = JSSecurityManager.createThread(this,
	"Java Sound Event Dispatcher", // name
	true, // daemon
	-1, // priority
	true); // doStart
	}
	}


	/**
	* Invoked when there is at least one event in the queue.
	* Implement this as a callback to process one event.
	*/
	void processEvent(EventInfo eventInfo) {
	int count = eventInfo.getListenerCount();

	// process an LineEvent
	if (eventInfo.getEvent() instanceof LineEvent) {
	LineEvent event = (LineEvent) eventInfo.getEvent();
	if (Printer.debug) Printer.debug("Sending "+event+" to "+count+" listeners");
	for (int i = 0; i < count; i++) {
	try {
	((LineListener) eventInfo.getListener(i)).update(event);
	} catch (Throwable t) {
	if (Printer.err) t.printStackTrace();
	}
	}
	return;
	}

	// process a MetaMessage
	if (eventInfo.getEvent() instanceof MetaMessage) {
	MetaMessage event = (MetaMessage)eventInfo.getEvent();
	for (int i = 0; i < count; i++) {
	try {
	((MetaEventListener) eventInfo.getListener(i)).meta(event);
	} catch (Throwable t) {
	if (Printer.err) t.printStackTrace();
	}
	}
	return;
	}

	// process a Controller or Mode Event
	if (eventInfo.getEvent() instanceof ShortMessage) {
	ShortMessage event = (ShortMessage)eventInfo.getEvent();
	int status = event.getStatus();

	// Controller and Mode events have status byte 0xBc, where
	// c is the channel they are sent on.
	if ((status & 0xF0) == 0xB0) {
	for (int i = 0; i < count; i++) {
	try {
	((ControllerEventListener) eventInfo.getListener(i)).controlChange(event);
	} catch (Throwable t) {
	if (Printer.err) t.printStackTrace();
	}
	}
	}
	return;
	}

	Printer.err("Unknown event type: " + eventInfo.getEvent());
	}


	/**
	* Wait until there is something in the event queue to process. Then
	* dispatch the event to the listeners.The entire method does not
	* need to be synchronized since this includes taking the event out
	* from the queue and processing the event. We only need to provide
	* exclusive access over the code where an event is removed from the
	*queue.
	*/
	void dispatchEvents() {

	EventInfo eventInfo = null;

	synchronized (this) {

	// Wait till there is an event in the event queue.
	try {

	if (eventQueue.size() == 0) {
	if (autoClosingClips.size() > 0 \|\| lineMonitors.size() > 0) {
	int waitTime = AUTO_CLOSE_TIME;
	if (lineMonitors.size() > 0) {
	waitTime = LINE_MONITOR_TIME;
	}
	wait(waitTime);
	} else {
	wait();
	}
	}
	} catch (InterruptedException e) {
	}
	if (eventQueue.size() > 0) {
	// Remove the event from the queue and dispatch it to the listeners.
	eventInfo = (EventInfo) eventQueue.remove(0);
	}

	} // end of synchronized
	if (eventInfo != null) {
	processEvent(eventInfo);
	} else {
	if (autoClosingClips.size() > 0) {
	closeAutoClosingClips();
	}
	if (lineMonitors.size() > 0) {
	monitorLines();
	}
	}
	}


	/**
	* Queue the given event in the event queue.
	*/
	private synchronized void postEvent(EventInfo eventInfo) {
	eventQueue.add(eventInfo);
	notifyAll();
	}


	/**
	* A loop to dispatch events.
	*/
	public void run() {

	while (true) {
	try {
	dispatchEvents();
	} catch (Throwable t) {
	if (Printer.err) t.printStackTrace();
	}
	}
	}


	/**
	* Send audio and MIDI events.
	*/
	void sendAudioEvents(Object event, List listeners) {
	if ((listeners == null)
	\|\| (listeners.size() == 0)) {
	// nothing to do
	return;
	}

	start();

	EventInfo eventInfo = new EventInfo(event, listeners);
	postEvent(eventInfo);
	}


	/*
	* go through the list of registered auto-closing
	* Clip instances and close them, if appropriate
	*
	* This method is called in regular intervals
	*/
	private void closeAutoClosingClips() {
	synchronized(autoClosingClips) {
	if (Printer.debug)Printer.debug("> EventDispatcher.closeAutoClosingClips ("+autoClosingClips.size()+" clips)");
	long currTime = System.currentTimeMillis();
	for (int i = autoClosingClips.size()-1; i >= 0 ; i--) {
	ClipInfo info = autoClosingClips.get(i);
	if (info.isExpired(currTime)) {
	AutoClosingClip clip = info.getClip();
	// sanity check
	if (!clip.isOpen() \|\| !clip.isAutoClosing()) {
	if (Printer.debug)Printer.debug("EventDispatcher: removing clip "+clip+" isOpen:"+clip.isOpen());
	autoClosingClips.remove(i);
	}
	else if (!clip.isRunning() && !clip.isActive() && clip.isAutoClosing()) {
	if (Printer.debug)Printer.debug("EventDispatcher: closing clip "+clip);
	clip.close();
	} else {
	if (Printer.debug)Printer.debug("Doing nothing with clip "+clip+":");
	if (Printer.debug)Printer.debug(" open="+clip.isOpen()+", autoclosing="+clip.isAutoClosing());
	if (Printer.debug)Printer.debug(" isRunning="+clip.isRunning()+", isActive="+clip.isActive());
	}
	} else {
	if (Printer.debug)Printer.debug("EventDispatcher: clip "+info.getClip()+" not yet expired");
	}
	}
	}
	if (Printer.debug)Printer.debug("< EventDispatcher.closeAutoClosingClips ("+autoClosingClips.size()+" clips)");
	}

	private int getAutoClosingClipIndex(AutoClosingClip clip) {
	synchronized(autoClosingClips) {
	for (int i = autoClosingClips.size()-1; i >= 0; i--) {
	if (clip.equals(autoClosingClips.get(i).getClip())) {
	return i;
	}
	}
	}
	return -1;
	}

	/**
	* called from auto-closing clips when one of their open() method is called
	*/
	void autoClosingClipOpened(AutoClosingClip clip) {
	if (Printer.debug)Printer.debug("> EventDispatcher.autoClosingClipOpened ");
	int index = 0;
	synchronized(autoClosingClips) {
	index = getAutoClosingClipIndex(clip);
	if (index == -1) {
	if (Printer.debug)Printer.debug("EventDispatcher: adding auto-closing clip "+clip);
	autoClosingClips.add(new ClipInfo(clip));
	}
	}
	if (index == -1) {
	synchronized (this) {
	// this is only for the case that the first clip is set to autoclosing,
	// and it is already open, and nothing is done with it.
	// EventDispatcher.process() method would block in wait() and
	// never close this first clip, keeping the device open.
	notifyAll();
	}
	}
	if (Printer.debug)Printer.debug("< EventDispatcher.autoClosingClipOpened finished("+autoClosingClips.size()+" clips)");
	}

	/**
	* called from auto-closing clips when their closed() method is called
	*/
	void autoClosingClipClosed(AutoClosingClip clip) {
	synchronized(autoClosingClips) {
	int index = getAutoClosingClipIndex(clip);
	if (index != -1) {
	autoClosingClips.remove(index);
	}
	}
	}


	// ////////////////////////// Line Monitoring Support /////////////////// //
	/*
	* go through the list of registered line monitors
	* and call their checkLine method
	*
	* This method is called in regular intervals
	*/
	private void monitorLines() {
	synchronized(lineMonitors) {
	if (Printer.debug)Printer.debug("> EventDispatcher.monitorLines ("+lineMonitors.size()+" monitors)");
	for (int i = 0; i < lineMonitors.size(); i++) {
	lineMonitors.get(i).checkLine();
	}
	}
	if (Printer.debug)Printer.debug("< EventDispatcher.monitorLines("+lineMonitors.size()+" monitors)");
	}


	/**
	* Add this LineMonitor instance to the list of monitors
	*/
	void addLineMonitor(LineMonitor lm) {
	if (Printer.trace)Printer.trace("> EventDispatcher.addLineMonitor("+lm+")");
	synchronized(lineMonitors) {
	if (lineMonitors.indexOf(lm) >= 0) {
	if (Printer.trace)Printer.trace("< EventDispatcher.addLineMonitor finished -- this monitor already exists!");
	return;
	}
	if (Printer.debug)Printer.debug("EventDispatcher: adding line monitor "+lm);
	lineMonitors.add(lm);
	}
	synchronized (this) {
	// need to interrupt the infinite wait()
	notifyAll();
	}
	if (Printer.debug)Printer.debug("< EventDispatcher.addLineMonitor finished -- now ("+lineMonitors.size()+" monitors)");
	}

	/**
	* Remove this LineMonitor instance from the list of monitors
	*/
	void removeLineMonitor(LineMonitor lm) {
	if (Printer.trace)Printer.trace("> EventDispatcher.removeLineMonitor("+lm+")");
	synchronized(lineMonitors) {
	if (lineMonitors.indexOf(lm) < 0) {
	if (Printer.trace)Printer.trace("< EventDispatcher.removeLineMonitor finished -- this monitor does not exist!");
	return;
	}
	if (Printer.debug)Printer.debug("EventDispatcher: removing line monitor "+lm);
	lineMonitors.remove(lm);
	}
	if (Printer.debug)Printer.debug("< EventDispatcher.removeLineMonitor finished -- now ("+lineMonitors.size()+" monitors)");
	}

	// /////////////////////////////////// INNER CLASSES ////////////////////////////////////////// //

	/**
	* Container for an event and a set of listeners to deliver it to.
	*/
	private class EventInfo {

	private final Object event;
	private final Object[] listeners;

	/**
	* Create a new instance of this event Info class
	* @param event the event to be dispatched
	* @param listeners listener list; will be copied
	*/
	EventInfo(Object event, List listeners) {
	this.event = event;
	this.listeners = listeners.toArray();
	}

	Object getEvent() {
	return event;
	}

	int getListenerCount() {
	return listeners.length;
	}

	Object getListener(int index) {
	return listeners[index];
	}

	} // class EventInfo


	/**
	* Container for a clip with its expiration time
	*/
	private class ClipInfo {

	private final AutoClosingClip clip;
	private final long expiration;

	/**
	* Create a new instance of this clip Info class
	*/
	ClipInfo(AutoClosingClip clip) {
	this.clip = clip;
	this.expiration = System.currentTimeMillis() + AUTO_CLOSE_TIME;
	}

	AutoClosingClip getClip() {
	return clip;
	}

	boolean isExpired(long currTime) {
	return currTime > expiration;
	}
	} // class ClipInfo


	/**
	* Interface that a class that wants to get regular
	* line monitor events implements
	*/
	interface LineMonitor {
	/**
	* Called by event dispatcher in regular intervals
	*/
	public void checkLine();
	}

	} // class EventDispatcher

Back to index...