To provide your users with this data, you need only a few variables - start time, number of bytes read and total size. With these variables you'll be able to compute any of the values listed above. It must be said, however, that some of these variables aren't always available. While downloading data from a servlet, for example, you won't know the full length of what you're downloading until it's over (and that's too late). This is also the case for most custom protocols over a socket connection.

Implementing the Classes
Since these classes must be able to be used from any source, they must inherit from java.io.InputStream and java.io.OutputStream. As I've said before, it's impossible to know the exact length of an InputStream or an OutputStream. This leaves us with two possibilities: force the developer to give it through a constructor, which allows us to provide needed values, or simply ignore it, in which case some values won't be available. The only exception to this problem is the java.net.URL object. With the java.net.URLConnection class, the developer will usually know the size of a download before reading it. To simplify the process, a special constructor has been made to handle URLs.

Here are the constructors for both wrapper classes:

Almost every method call is simply a call to its equivalent on the private internal instance. The available() method of DownloadInputStream calls the available() method on the private instance of the InputStream given through the constructor.

public int available() throws IOException {
return internalInputStream.available();
}

You need to know the starting time and the number of bytes being read up to now. To provide the user with this data, you need to reimplement the read(...) and write(...) methods so that the information is computed as the stream is being used. The following code shows the reimplementation of the read(...) method of the DownloadInputStream.

public int read(byte[] b, int off, int len)
throws IOException {
if (startTime == -1)
startTime = System.currentTimeMillis();

int read = internalInputStream.read(b,off,len);
bytesRead += read;
return read;
}

All you have to do is implement new methods that'll compute all the information you need to know about these streams with the new variables.

The transfer rate is quite simple - divide the number of bytes being read by the elapsed download time. The result is in bytes per millisecond. See Listing 1 for the exact implementation of this method.

The estimated remaining download or upload time is computed with an interpolation that relies on the transfer rate you've just computed. The hypothesis is that the rest of the data to be transferred will be downloaded/uploaded at approximately the same rate as the first part. The -1 value is returned if the full length of the input or output stream is unknown. The exact implementation of this method is shown in Listing 2.

Example
Finally, since a bit of code is worth a thousand words, I've provided an example to prove how simple it can be to use these classes. It's a short program that downloads a given file from a URL on the local disk. While the file is being downloaded, data such as transfer rate, estimated remaining download time and a progress bar will show the user the state of his or her download (see Figure 3). See Listing 3 for the full example code.

Limitations
Keep in mind that the data provided by these classes must be carefully interpreted. If you build a program that calls the read(...) method every five minutes, you won't get the exact transfer rate and estimated download time whether you're using a 100Mb LAN or a dial-up modem. Since the interpolation is really simple, it can't handle extreme cases such as this.

With this in mind, you'll now be able to use these classes to provide your users with all the data they want to know. Since these classes can be used with the same methods as the common Java Input and Output Streams, you won't have to go through a learning curve.