Revision 5245 branches/MULTITHREADING_DEVELOPMENT/libraries/libRemoteServices/src/org/gvsig/remoteClient/taskplanning/retrieving/URLRetrieveTask.java

View differences:

URLRetrieveTask.java
26 26
27 27 
	private boolean running, cancelled;
28 28 
	private URLRequest request;
29 
	private Vector listeners = new Vector();
30 
	private RetrieveEvent event = new RetrieveEvent();
31 29 
	private InputStream is;
32 30
33 31 
	/**
34 32 
	 *
35 33 
	 */
36 
	public URLRetrieveTask(URLRequest request, RetrieveListener listener) {
34 
	public URLRetrieveTask(URLRequest request) {
37 35 
		this.request = request;
38 
		addRetrieveListener(listener);
39 36 
		running = cancelled = false;
40 37 
	}
41 38
42 39 

  		




  43
  40
  
    
	public void execute() {


  		




  44
  
  
    
		event.setType(RetrieveEvent.NOT_STARTED);


  		




  45
  
  
    
		fireEvent();


  		




  
  41
  
    
		request.setStatus(RetrieveEvent.NOT_STARTED);


  		




  46
  42
  
    
		cancelled = false;


  		




  47
  43
  
    
		running= true;


  		




  48
  44
  
    
		


  		




  ......




  54
  50
  
    
		}


  		




  55
  51
  
    
		URL url;


  		




  56
  52
  
    
		try {


  		




  57
  
  
    
			event.setType(RetrieveEvent.CONNECTING);


  		




  58
  
  
    
			fireEvent();


  		




  
  53
  
    
			request.setStatus(RetrieveEvent.CONNECTING);


  		




  
  54
  
    
			


  		




  59
  55
  
    
			url = request.getUrl();


  		




  60
  56
  
    
			request.setFileName(f.getAbsolutePath());


  		




  61
  57
  
    
			System.out.println("downloading '"+url+"' to: "+f.getAbsolutePath());


  		




  62
  58
  
    
			


  		




  63
  59
  
    
			DataOutputStream dos = new DataOutputStream( new BufferedOutputStream(new FileOutputStream(f)));


  		




  64
  60
  
    
			byte[] buffer = new byte[1024*256];


  		




  65
  
  
    
			fireEvent();


  		




  66
  61
  
    
			is = url.openStream();


  		




  67
  
  
    
			event.setType(RetrieveEvent.TRANSFERRING);


  		




  68
  
  
    
			fireEvent();


  		




  
  62
  
    
			request.setStatus(RetrieveEvent.TRANSFERRING);


  		




  69
  63
  
    
			if (!cancelled) {


  		




  70
  64
  
    
				long readed = 0;


  		




  71
  65
  
    
				for (int i = is.read(buffer); !cancelled && i>0; i = is.read(buffer)){


  		




  ......




  84
  78
  
    
				// register job in the cache


  		




  85
  79
  
    
				// TODO aix? deuria d'estar al principi per a poder capturar


  		




  86
  80
  
    
				// treballs que s'estan fent per? que encara no s'han acabat


  		




  87
  
  
    
				synchronized (this) {


  		




  88
  
  
    
					RequestManager.getInstance().addDownloadedURLRequest(request, f.getAbsolutePath());


  		




  89
  
  
    
				}


  		




  
  81
  
    
//				synchronized (this) {


  		




  
  82
  
    
//					RequestManager.getInstance().addDownloadedURLRequest(request);


  		




  
  83
  
    
//				}


  		




  90
  84
  
    
			}


  		




  91
  85
  
    
			


  		




  92
  86
  
    
			running = false;


  		




  93
  87
  
    
			if (cancelled)


  		




  94
  
  
    
				event.setType(RetrieveEvent.REQUEST_CANCELLED);


  		




  
  88
  
    
				request.setStatus(RetrieveEvent.REQUEST_CANCELLED);


  		




  95
  89
  
    
			else


  		




  96
  
  
    
				event.setType(RetrieveEvent.REQUEST_FINISHED);


  		




  
  90
  
    
				request.setStatus(RetrieveEvent.REQUEST_FINISHED);


  		




  97
  91
  
    
			


  		




  98
  92
  
    
		} catch (MalformedURLException e) {


  		




  99
  93
  
    
			e.printStackTrace();


  		




  100
  
  
    
			event.setType(RetrieveEvent.REQUEST_FAILED);


  		




  
  94
  
    
			request.setStatus(RetrieveEvent.REQUEST_FAILED);


  		




  101
  95
  
    
		} catch (IOException e) {


  		




  102
  96
  
    
			e.printStackTrace();


  		




  103
  
  
    
			event.setType(RetrieveEvent.REQUEST_FAILED);


  		




  
  97
  
    
			request.setStatus(RetrieveEvent.REQUEST_FAILED);


  		




  104
  98
  
    
		}


  		




  105
  
  
    
		fireEvent();


  		




  106
  99
  
    
	}


  		




  107
  100
  
    

  		




  108
  
  
    
	private void fireEvent() {


  		




  109
  
  
    
		Iterator it = listeners.iterator();


  		




  110
  
  
    
		while (it.hasNext()) {


  		




  111
  
  
    
			RetrieveListener listener = (RetrieveListener) it.next();


  		




  112
  
  
    
			listener.transferEventReceived(event);		


  		




  113
  
  
    
		}


  		




  114
  
  
    
	}


  		




  
  101
  
    
//	private void fireEvent() {


  		




  
  102
  
    
//		Iterator it = listeners.iterator();


  		




  
  103
  
    
//		while (it.hasNext()) {


  		




  
  104
  
    
//			RetrieveListener listener = (RetrieveListener) it.next();


  		




  
  105
  
    
//			listener.transferEventReceived(event);		


  		




  
  106
  
    
//		}


  		




  
  107
  
    
//	}


  		




  115
  108
  
    

  		




  116
  
  
    
	public void addRetrieveListener(RetrieveListener l) {


  		




  117
  
  
    
		if (l!=null)


  		




  118
  
  
    
			listeners.add(l);


  		




  119
  
  
    
	}


  		




  120
  
  
    

  		




  121
  109
  
    
	public void cancel() {


  		




  122
  110
  
    
		cancelled = true;


  		




  123
  111
  
    
		try {


  		




  ......




  138
  126
  
    
	public URLRequest getRequest() {


  		




  139
  127
  
    
		return request;


  		




  140
  128
  
    
	}


  		




  141
  
  
    

  		




  142
  
  
    

  		




  143
  
  
    
	public Vector getListeners() {


  		




  144
  
  
    
		return listeners;


  		




  145
  
  
    
	}


  		




  146
  129
  
    
}


  		




  147
  130
  
    

  		




  148
  131
  
    

  		












Also available in:  Unified diff