|
|
Progress Monitored Data Transfer Java code example - Click here to copy ->>>
Can't find what you're looking for? Try our search:
|
|
Really working examples categorized by API, package, class. You can compile and run our examples right away!
Not from source code for Java projects - only working examples! Copy, compile and run!
|
------------------
| Code: |
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;
/**
* Transfer data from one stream to another,
* providing a Swing ProgressMonitor to handle
* notifying the user and allowing the user to
* cancel the transfer. The progress updates
* every half-second.
* <p>Objects of this class
* also act as Observables, updating their
* observers after each block of data is
* transfered, and again at the end of the
* transfer.
*/
public class ProgressMonitoredDataTransfer
extends java.util.Observable
implements Runnable, ActionListener
{
private InputStream readFrom;
private OutputStream writeTo;
private ProgressMonitor monitor;
private boolean done;
private int max;
private int current;
private Timer mytimer;
private Thread mythread;
private boolean closeWhenDone;
public static final int DELAY = 500;
public static final int BUFSIZ = 1024;
/**
* Create a progress monitored data transfer.
*
* @param par Parent Swing Window or Frame
* @param from Stream to read data from
* @param to Stream to write data out to
* @param maxtransfer Maximum number of bytes we expect to transfer
* @param message Progress monitor message object (usually String)
* @param close If set, then close the streams at end of transfer
*/
public ProgressMonitoredDataTransfer(Component par,
InputStream from, OutputStream to,
int maxtransfer, Object message,
boolean close)
{
readFrom = new BufferedInputStream(from);
writeTo = to;
max = maxtransfer;
monitor = new ProgressMonitor(par, message, null, 0, max);
monitor.setMillisToPopup(2*DELAY);
mythread = new Thread(this);
mytimer = new Timer(DELAY, this);
done = false;
closeWhenDone = close;
current = 0;
mythread.start();
mytimer.start();
}
/**
* Handle timer actions.
*/
public void actionPerformed(ActionEvent e) {
if (isDone()) {
// if the transfer is done, close the monitor
monitor.close();
mytimer.stop();
}
else if (monitor.isCanceled()) {
// if the user hits cancel, then interrupt our thread
if (mythread != null && mythread.isAlive())
mythread.interrupt();
monitor.close();
mytimer.stop();
}
else {
// otherwise, just
// retrieve the current progress value and...
int cur = getCurrent();
// ...then update the monitor!
monitor.setProgress(cur);
}
}
/**
* Override this to handle problems differently. Note that
* this method may or may not be called from the
* Swing event thread. The default implementation
* just prints to System.err.
*
* @param msg Message about the problem
*/
public void handleProblem(String msg) {
System.err.println("Transfer problem: " + msg);
}
/**
* Retrieve the value of current, which is the
* number of bytes transferred so far.
*
* @returns number of bytes transfered
*/
public synchronized int getCurrent() { return current; }
private synchronized void addToCurrent(int x) { current += x; }
/**
* Check whether the task is done yet.
*/
public synchronized boolean isDone() { return done; }
private synchronized void setDone() {
done = true;
setChanged();
notifyObservers("Done");
}
/**
* Wait for the task to be done.
* It is probably not a good idea to use this in Swing.
*/
public void waitForDone() {
try { mythread.join(); } catch (InterruptedException ie) { }
return;
}
/**
* Dont override this.
*/
public void run() {
try {
byte buf[] = new byte[BUFSIZ];
int cc;
for(cc = readFrom.read(buf, 0, BUFSIZ);
cc > 0;
cc = readFrom.read(buf, 0, BUFSIZ))
{
writeTo.write(buf, 0, cc);
addToCurrent(cc); // update the current progress value
// Thread.sleep(200);
if (mythread.isInterrupted()) break;
setChanged();
notifyObservers(null);
}
}
catch (InterruptedIOException ioe) {
handleProblem("Cancelled by user after " +
current + " bytes.");
}
catch (Exception ie) {
handleProblem("IO exception: " + ie);
}
finally {
setDone();
if (closeWhenDone) {
if (readFrom != null) {
try { readFrom.close(); }
catch (Exception e2) { }
}
if (writeTo != null) {
try { writeTo.close(); }
catch (Exception e3) { }
}
}
}
}
}
|
|
|
References.
The list of classes which were used on this page you can find below. The
links to Java API contain official SUN documentation about all used classes.
[ Go Back ]
|
|
RSS feed Java Forums
Microsoft warns of Java flaws...