package org.jivesoftware.smackx.filetransfer; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import org.jivesoftware.smack.XMPPException; /** * Contains the generic file information and progress related to a particular * file transfer. * * @author Alexander Wenckus * */ public abstract class FileTransfer { private String fileName; private String filePath; private long fileSize; private String peer; private org.jivesoftware.smackx.filetransfer.FileTransfer.Status status; protected FileTransferNegotiator negotiator; protected String streamID; protected long amountWritten = -1; private Error error; private Exception exception; protected FileTransfer(String peer, String streamID, FileTransferNegotiator negotiator) { this.peer = peer; this.streamID = streamID; this.negotiator = negotiator; } protected void setFileInfo(String fileName, long fileSize) { this.fileName = fileName; this.fileSize = fileSize; } protected void setFileInfo(String path, String fileName, long fileSize) { this.filePath = path; this.fileName = fileName; this.fileSize = fileSize; } /** * Returns the size of the file being transfered. * * @return Returns the size of the file being transfered. */ public long getFileSize() { return fileSize; } /** * Returns the name of the file being transfered. * * @return Returns the name of the file being transfered. */ public String getFileName() { return fileName; } /** * Returns the local path of the file. * * @return Returns the local path of the file. */ public String getFilePath() { return filePath; } /** * Returns the JID of the peer for this file transfer. * * @return Returns the JID of the peer for this file transfer. */ public String getPeer() { return peer; } /** * Returns the progress of the file transfer as a number between 0 and 1. * * @return Returns the progress of the file transfer as a number between 0 * and 1. */ public double getProgress() { return 0; } /** * Returns true if the transfer has been cancled, if it has stopped because * of a an error, or the transfer completed succesfully. * * @return Returns true if the transfer has been cancled, if it has stopped * because of a an error, or the transfer completed succesfully. */ public boolean isDone() { return status == Status.CANCLED || status == Status.ERROR || status == Status.COMPLETE; } /** * Retuns the current status of the file transfer. * * @return Retuns the current status of the file transfer. */ public Status getStatus() { return status; } protected void setError(Error type) { this.error = type; } /** * When {@link #getStatus()} returns that there was an {@link Status#ERROR} * during the transfer, the type of error can be retrieved through this * method. * * @return Returns the type of error that occured if one has occured. */ public Error getError() { return error; } /** * If an exception occurs asynchronously it will be stored for later * retrival. If there is an error there maybe an exception set. * * @return The exception that occured or null if there was no exception. * @see #getError() */ public Exception getException() { return exception; } /** * Cancels the file transfer. */ public abstract void cancel(); protected void setException(Exception exception) { this.exception = exception; } protected final void setStatus(Status status) { this.status = status; } protected void writeToStream(final InputStream in, final OutputStream out) throws XMPPException { final byte[] b = new byte[1000]; int count = 0; amountWritten = 0; try { count = in.read(b); } catch (IOException e) { throw new XMPPException("error reading from input stream", e); } while (count != -1 && !getStatus().equals(Status.CANCLED)) { if (getStatus().equals(Status.CANCLED)) { return; } // write to the output stream try { out.write(b, 0, count); } catch (IOException e) { throw new XMPPException("error writing to output stream", e); } amountWritten += count; // read more bytes from the input stream try { count = in.read(b); } catch (IOException e) { throw new XMPPException("error reading from input stream", e); } } // the connection was likely terminated abrubtly if these are not // equal if (!getStatus().equals(Status.CANCLED) && getError() == Error.NONE && amountWritten != fileSize) { this.error = Error.CONNECTION; } } /** * A class to represent the current status of the file transfer. * * @author Alexander Wenckus * */ public static class Status { /** * An error occured during the transfer. * * @see FileTransfer#getError() */ public static final Status ERROR = new Status(); /** * The file transfer is being negotiated with the peer. The party * recieving the file has the option to accept or refuse a file transfer * request. If they accept, then the process of stream negotiation will * begin. If they refuse the file will not be transfered. * * @see #NEGOTIATING_STREAM */ public static final Status NEGOTIATING_TRANSFER = new Status(); /** * The peer has refused the file transfer request halting the file * transfer negotiation process. */ public static final Status REFUSED = new Status(); /** * The stream to transfer the file is being negotiated over the chosen * stream type. After the stream negotiating process is complete the * status becomes negotiated. * * @see #NEGOTIATED */ public static final Status NEGOTIATING_STREAM = new Status(); /** * After the stream negotitation has completed the intermediate state * between the time when the negotiation is finished and the actual * transfer begins. */ public static final Status NEGOTIATED = new Status(); /** * The transfer is in progress. * * @see FileTransfer#getProgress() */ public static final Status IN_PROGRESS = new Status(); /** * The transfer has completed successfully. */ public static final Status COMPLETE = new Status(); /** * The file transfer was canceled */ public static final Status CANCLED = new Status(); } public static class Error { /** * No error */ public static final Error NONE = new Error("No error"); /** * The peer did not find any of the provided stream mechanisms * acceptable. */ public static final Error NOT_ACCEPTABLE = new Error( "The peer did not find any of the provided stream mechanisms acceptable."); /** * The provided file to transfer does not exist or could not be read. */ public static final Error BAD_FILE = new Error( "The provided file to transfer does not exist or could not be read."); /** * The remote user did not respond or the connection timed out. */ public static final Error NO_RESPONSE = new Error( "The remote user did not respond or the connection timed out."); /** * An error occured over the socket connected to send the file. */ public static final Error CONNECTION = new Error( "An error occured over the socket connected to send the file."); /** * An error occured while sending or recieving the file */ protected static final Error STREAM = new Error( "An error occured while sending or recieving the file"); private final String msg; private Error(String msg) { this.msg = msg; } /** * Returns a String representation of this error. * * @return Returns a String representation of this error. */ public String getMessage() { return msg; } public String toString() { return msg; } } }