/ - Diff - Application: gvSIG desktop - gvSIG

Revision 38431

     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.task.AbstractMonitorableTask;
     import org.gvsig.tools.task.SimpleTaskStatus;
     import org.gvsig.tools.task.TaskStatusManager;
     /**
      * @author gvSIG Team
-...
     public class Download extends AbstractMonitorableTask {
     	private static final Logger LOG = LoggerFactory.getLogger(Download.class);
     	private boolean isMyTaskStatus;
     	/**
     	 * If file size provided by URLConnection is smaller than this,
     	 * then the downloaded file size will always be accepted (unit: bytes)
     	 */
         private static final int FILE_SIZE_ESTIMATED_MINIMUM = 10000;
         /**
          * Downloaded file size will be accepted if it is bigger than this ratio
          * multiplied by the estimated file size provided by URLConnection
          * (unit: bytes)
          */
         private static final double FILE_SIZE_ESTIMATED_RATIO = 0.85;
     	private boolean selfCreatedTaskStatus = true;
     	/**
     	 * @param taskName
     	 */
     	public Download(SimpleTaskStatus taskStatus) {
     		this();
     		/*
     		 * constructor without params is adding
     		 * itself to manager, so we remove it
     		 */
             TaskStatusManager manager = ToolsLocator.getTaskStatusManager();
             manager.remove(getTaskStatus());
             /*
              * The received taskstatus is being managed by somebody else,
              * we don not add it to the manager
              */
     		this.taskStatus = taskStatus;
     		isMyTaskStatus = false;
     		selfCreatedTaskStatus = false;
+    	}
     	public Download() {
     	    /**
     	     * this call is adding the task status to the manager
     	     */
     		super("Downloading...");
     		isMyTaskStatus = true;
+    	}
     	public File downloadFile(URL url, String defaultFileName)
-...
     		BufferedOutputStream bos = new BufferedOutputStream(
     				new FileOutputStream(localFile));
     		this.taskStatus.setRangeOfValues(0, connection.getContentLength());
     		int expected_size = connection.getContentLength();
     		this.taskStatus.setRangeOfValues(0, expected_size);
     		try {
     			byte[] data = new byte[1024];
     			int count = 0;
     			long totalCount = 0; // total bytes readed
     			long totalCount = 0; // total bytes read
     			while ((count = bis.read(data, 0, 1024)) >= 0) {
     				bos.write(data, 0, count);
     				totalCount += count;
     				this.taskStatus.setCurValue(totalCount);
     				if (this.taskStatus.isCancellationRequested()) {
     					return null;
     					break;
+    				}
+    			}
     			if (isMyTaskStatus) {
     			if (selfCreatedTaskStatus) {
     				this.taskStatus.terminate();
     				this.taskStatus.remove();
+    			}
     			// out from the read loop
     			// perhaps it was cancelled:
                 if (this.taskStatus.isCancellationRequested()) {
                     return null;
+                }
                 // check real size = expected size:
                 if (!acceptableFileSize(localFile, expected_size)) {
                     throw new IOException("Bad download file size ("
                         + localFile.length()
                         + " / "
                         + expected_size
                         + ")");
+                }
                 // everything seems to be OK
     			return localFile;
     		} finally {
     			bis.close();
-...
     		return null;
+    	}
     	/**
     	 * {@link URLConnection}'s method getContentLength() does not give
     	 * exact size.
+    	 *
     	 * @return whether the size is acceptable
     	 */
     	public static boolean acceptableFileSize(File f, int estimated_size) {
     	    if (f == null) {
     	        return false;
+    	    }
     	    if (estimated_size == -1) {
     	        // -1 means unknown
     	        return true;
+    	    }
     	    if (estimated_size < FILE_SIZE_ESTIMATED_MINIMUM) {
     	        return true;
+    	    }
     	    return f.length() > (FILE_SIZE_ESTIMATED_RATIO * estimated_size);
+    	}
+    }

Also available in: Unified diff