EXTENDED EXAMPLE: HOME AUDIO SYSTEM in Font

Print DataMatrix in Font EXTENDED EXAMPLE: HOME AUDIO SYSTEM

and /** * Sink.java * A sink for audio */ package audio.common; import java.rmi.RemoteException; import net.jini.core.event.EventRegistration; import net.jini.core.event.RemoteEventListener; import java.rmi.MarshalledObject; public interface Sink extends java.rmi.Remote { int STOP = 1; void record() throws RemoteException, AlreadyRecordingException; void stop() throws RemoteException, NotRecordingException; void addSource(Source src) throws RemoteException, TooManySourcesException, IncompatableSourceException; void removeSource(Source src) throws RemoteException, NoSuchSourceException; EventRegistration addSinkListener(RemoteEventListener listener, MarshalledObject handback) throws RemoteException; void removeSinkListener(RemoteEventListener listener) throws RemoteException, NoSuchListenerException; }// Sink

The Java Media Framework (JMF) has methods such as getSupportedContentTypes(), which returns an array of strings. Other media toolkits have similar mechanisms. This type of mechanism isn t type-safe: it relies on all parties having the same strings and attaching the same meaning to each. In addition, if a new type comes along, there isn t a reliable means of specifying this information to others. A type-safe system can at least specify this by class files. In this example system, I have chosen to use interfaces instead of strings: a WAV interface, an Ogg interface, and so on. This doesn t easily allow extension to the multiplicity of content type variations (bit size, sampling rate, etc.), but the current content handlers appear to be able to handle most of these variations anyway, so it seems feasible to ignore them at an application level.

The content interfaces are just placeholders: package presentation; public interface Ogg extends java.rmi.Remote { } A source that could make an audio stream available in Ogg Vorbis format would signal this by implementing the Ogg interface. A sink that can manage Ogg Vorbis streams would also implement this interface.

In a similar way, I have chosen to represent the transport mechanisms by interfaces. A transport sink will get the information from a source using some unspecified network transport mechanism. The audio stream can be made available to any other object by exposing an InputStream. This is a standard Java stream, not the special one used by JMF. Similarly, a transport source would make an output stream available for source-side objects to write data into. The transport interfaces are this: /** * TransportSink.java */ package audio.transport; import java.io.*; public interface TransportSink { public InputStream getInputStream(); }// TransportSink and this: /** * TransportSource.java */ package audio.transport; import java.io.*; public interface TransportSource { public OutputStream getOutputStream(); }// TransportSource

By separating the transport and content layers, we have a model that follows part of the ISO seven layer model: transport and presentation layers. The communication paths for a pull sink are shown in Figure 27-2.

Figure 27-2. Data flow from a source to a pull sink The classes involved in a pull sink could look like Figure 27-3.

Figure 27-3. Classes in a pull sink Here, the choice of transport and content implementation is based on the interfaces supported by the source and the preferences of the sink.

An HTTP source makes an audio stream available as a document from an HTTP server. It simply needs to tell a sink about the URL for the document. There is a small hiccup in this:

a Java URL can be an http URL, a file URL, an ftp URL, and so on. So I have defined an HttpURL class to enforce that it is a URL accessible by the HTTP protocol. The Java URL class is final, so we can t extend it and have to wrap around it. /** * HttpURL.java */ package audio.transport; import java.net.MalformedURLException; import java.net.*; import java.io.*; public class HttpURL implements java.io.Serializable { private URL url; public HttpURL(URL url) throws MalformedURLException { this.url = url; if (! url.getProtocol().equals("http")) { throw new MalformedURLException("Not http URL"); } } public HttpURL(String spec) throws MalformedURLException { url = new URL(spec); if (! url.getProtocol().equals("http")) { throw new MalformedURLException("Not http URL"); } } public URLConnection openConnection() throws IOException { return url.openConnection(); } public InputStream openStream() throws IOException { return url.openStream(); } }// HttpURL The HttpSource interface just exposes an HttpURL: /** * HttpSource.java */ package audio.transport; import audio.common.*; import java.net.URL; import java.rmi.RemoteException; public interface HttpSource extends Source { HttpURL getHttpURL() throws RemoteException; }// HttpSource