InputStream ou Lecteur de wrapper pour les rapports sur les progrès

Voici un pas assez mise en œuvre de base que les feux de PropertyChangeEvents quand d'autres octets sont lus. Quelques mises en garde:

• La classe ne prend pas en charge mark ou reset opérations, bien que celles-ci seraient faciles à ajouter.
• La classe ne permet pas de vérifier si le nombre total d'octets lus jamais dépasse le nombre maximum d'octets anticipé, même si cela pouvait toujours être traitée par le code du client lors de l'affichage de progrès.
• Je n'ai pas tester le code.

Code:

public class ProgressInputStream extends FilterInputStream {
private final PropertyChangeSupport propertyChangeSupport;
private final long maxNumBytes;
private volatile long totalNumBytesRead;
public ProgressInputStream(InputStream in, long maxNumBytes) {
super(in);
this.propertyChangeSupport = new PropertyChangeSupport(this);
this.maxNumBytes = maxNumBytes;
}
public long getMaxNumBytes() {
return maxNumBytes;
}
public long getTotalNumBytesRead() {
return totalNumBytesRead;
}
public void addPropertyChangeListener(PropertyChangeListener l) {
propertyChangeSupport.addPropertyChangeListener(l);
}
public void removePropertyChangeListener(PropertyChangeListener l) {
propertyChangeSupport.removePropertyChangeListener(l);
}
@Override
public int read() throws IOException {
int b = super.read();
updateProgress(1);
return b;
}
@Override
public int read(byte[] b) throws IOException {
return (int)updateProgress(super.read(b));
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
return (int)updateProgress(super.read(b, off, len));
}
@Override
public long skip(long n) throws IOException {
return updateProgress(super.skip(n));
}
@Override
public void mark(int readlimit) {
throw new UnsupportedOperationException();
}
@Override
public void reset() throws IOException {
throw new UnsupportedOperationException();
}
@Override
public boolean markSupported() {
return false;
}
private long updateProgress(long numBytesRead) {
if (numBytesRead > 0) {
long oldTotalNumBytesRead = this.totalNumBytesRead;
this.totalNumBytesRead += numBytesRead;
propertyChangeSupport.firePropertyChange("totalNumBytesRead", oldTotalNumBytesRead, this.totalNumBytesRead);
}
return numBytesRead;
}
}

OriginalL'auteur Adamski

La réponse par Adamski fonctionne, mais il y a un petit bug. Le substituée read(byte[] b) méthode appelle la read(byte[] b, int off, int len) méthode creux de la super-classe.

Donc updateProgress(long numBytesRead) est appelé deux fois pour chaque lecture de l'action et vous vous retrouvez avec un numBytesRead qui est deux fois la taille du fichier après le total des fichier a été lu.

Pas primordial read(byte[] b) méthode résout le problème.

OriginalL'auteur WillamS

Pour compléter la réponse donnée par @Kevin Bourillion, il peut être appliqué à un réseau de contenu à l'aide de cette technique (qui empêche la lecture du flux à deux fois : l'une pour la taille et l'autre pour le contenu) :

        final HttpURLConnection httpURLConnection = (HttpURLConnection) new URL( url ).openConnection();
InputSupplier< InputStream > supplier = new InputSupplier< InputStream >() {
public InputStream getInput() throws IOException {
return httpURLConnection.getInputStream();
}
};
long total = httpURLConnection.getContentLength();
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
ByteStreams.readBytes( supplier, new ProgressByteProcessor( bos, total ) );

Où ProgressByteProcessor est un intérieur de classe :

public class ProgressByteProcessor implements ByteProcessor< Void > {
private OutputStream bos;
private long progress;
private long total;
public ProgressByteProcessor( OutputStream bos, long total ) {
this.bos = bos;
this.total = total;
}
public boolean processBytes( byte[] buffer, int offset, int length ) throws IOException {
bos.write( buffer, offset, length );
progress += length - offset;
publishProgress( (float) progress / total );
return true;
}
public Void getResult() {
return null;
}
}

OriginalL'auteur Snicolas