downloadmanagercontroller.java

一个基于JAVA的多torrent下载程序

  			setFailed( MessageText.getString("DownloadManager.error.datamissing") + " " + strErrMessage );
  
  			return( false );
  		}
  		
  		return( true );
	}
	
   	public DiskManagerFileInfo[]
    getDiskManagerFileInfo()
   	{
   		return( files_facade );
   	}
	
	protected void
	fileInfoChanged()
	{
		skeleton_files = null;
	}
	
	protected PEPeerManager
	getPeerManager()
	{
		return( peer_manager );
	}
	
	protected DiskManager
	getDiskManager()
	{
		return( disk_manager_use_accessors );
	}
	
	protected String
	getErrorDetail()
	{
		return( errorDetail );
	}
	
 	protected void
  	setDiskManager(
  		DiskManager	new_disk_manager )
  	{
 	 	try{
	  		disk_listeners_mon.enter();
	  		
	  		DiskManager	old_disk_manager = disk_manager_use_accessors;
	  		
	  		disk_manager_use_accessors	= new_disk_manager;

	  			// whether going from none->active or the other way, indicate that the file info
	  			// has changed
	  		
	  		fileInfoChanged();
	  		
	  		if ( new_disk_manager == null && old_disk_manager != null ){
	  				  			
	  			disk_listeners.dispatch( LDT_DL_REMOVED, old_disk_manager );
	  			
	  		}else if ( new_disk_manager != null && old_disk_manager == null ){
	  			
	  			disk_listeners.dispatch( LDT_DL_ADDED, new_disk_manager );
	  			
	  		}else{
	  		
	  			Debug.out( "inconsistent DiskManager state - " + new_disk_manager + "/" + old_disk_manager  );
	  		}
	  		
	  	}finally{
	  		
	  		disk_listeners_mon.exit();
	  	}	
  	}
  	
	public void
	addDiskListener(
		DownloadManagerDiskListener	listener )
	{
	 	try{
	  		disk_listeners_mon.enter();
	  		
	  		disk_listeners.addListener( listener );
	  		
	  		DiskManager	dm = getDiskManager();
	  		
			if ( dm != null ){
		
				disk_listeners.dispatch( listener, LDT_DL_ADDED, dm );
			}
	  	}finally{
	  		
	  		disk_listeners_mon.exit();
	  	}		
	}
		
	public void
	removeDiskListener(
		DownloadManagerDiskListener	listener )
	{
	 	try{
	  		disk_listeners_mon.enter();

	  		disk_listeners.removeListener( listener );
	  		
	 	}finally{
	  		
	  		disk_listeners_mon.exit();
	  	}
	}
	
	public String
	getDisplayName()
	{
		return( download_manager.getDisplayName());
	}
	
	public int
	getUploadRateLimitBytesPerSecond()
	{
		return( stats.getUploadRateLimitBytesPerSecond());
	}
	
	public int
	getDownloadRateLimitBytesPerSecond()
	{
		return( stats.getDownloadRateLimitBytesPerSecond());
	}
	
	public int
	getMaxUploads()
	{
		return( stats.getEffectiveMaxUploads());
	}
	
	public int
	getMaxConnections()
	{
		return( download_manager.getMaxConnections());
	}
	
	public boolean
	isAZMessagingEnabled()
	{
		return( download_manager.isAZMessagingEnabled());
	}
	
	public boolean
	isPeerExchangeEnabled()
	{
		return( download_manager.getDownloadState().isPeerSourceEnabled( PEPeerSource.PS_OTHER_PEER ));
	}
	
	public boolean
	isPeriodicRescanEnabled()
	{
		return( download_manager.getDownloadState().getFlag( DownloadManagerState.FLAG_SCAN_INCOMPLETE_PIECES ));
	}
	
	public TRTrackerScraperResponse
	getTrackerScrapeResponse()
	{
		return( download_manager.getTrackerScrapeResponse());
	}
	
	public String
	getTrackerClientExtensions()
	{
		return( download_manager.getDownloadState().getTrackerClientExtensions());
	}
	
	public void
	setTrackerRefreshDelayOverrides(
		int	percent )
	{
		download_manager.setTrackerRefreshDelayOverrides( percent );
	}
	
	public boolean
	isNATHealthy()
	{
		return( download_manager.getNATStatus() == ConnectionManager.NAT_OK );
	}
	
	public void
	addPeer(
		PEPeer	peer )
	{
		download_manager.addPeer( peer );
	}
	
	public void
	removePeer(
		PEPeer	peer )
	{	
		download_manager.removePeer( peer );
	}
	
	public void
	addPiece(
		PEPiece	piece )
	{
		download_manager.addPiece( piece );
	}
	
	public void
	removePiece(
		PEPiece	piece )
	{
		download_manager.removePiece( piece );
	}
	
	public void
	discarded(
		int	bytes )
	{
		if ( global_stats != null ){
			
			global_stats.discarded( bytes );
		}
	}
	
	public void
	protocolBytesReceived(
		int	bytes )
	{
		if ( global_stats != null ){
			
			global_stats.protocolBytesReceived( bytes );
		}
	}
	
	public void
	dataBytesReceived(
		int	bytes )
	{
		if ( global_stats != null ){
			
			global_stats.dataBytesReceived( bytes );
		}
	}
	
	public void
	protocolBytesSent(
		int	bytes )
	{
		if ( global_stats != null ){
			
			global_stats.protocolBytesSent( bytes );
		}
	}
	
	public void
	dataBytesSent(
		int	bytes )
	{
		if ( global_stats != null ){
			
			global_stats.dataBytesSent( bytes );
		}
	}
	
	public LogRelation
	getLogRelation()
	{
		return( this );
	}
	
	public String
	getRelationText() 
	{
		return( download_manager.getRelationText());
	}

	public Object[] 
	getQueryableInterfaces() 
	{
		List	interfaces = new ArrayList();
		
		Object[]	intf = download_manager.getQueryableInterfaces();
		
		for (int i=0;i<intf.length;i++){
			
			interfaces.add( intf[i] );
		}
		
		interfaces.add( download_manager );
		
		DiskManager	dm = getDiskManager();
		
		if ( dm != null ){
			
			interfaces.add( dm );
		}
		
		return( interfaces.toArray());
	}
	
	protected class
	fileInfoFacade
		implements DiskManagerFileInfo
	{
		private DiskManagerFileInfo		delegate;
		private int						index;
		
		protected 
		fileInfoFacade(
			int	_index )
		{
			index	= _index;
		}
		
		protected void
		fixup()
		{
	 		DiskManager	dm = DownloadManagerController.this.getDiskManager();

	   		DiskManagerFileInfo[]	res	= null;
	   		
	   		if ( dm != null ){
	   			
	   			int	dm_state = dm.getState();
	   			
	   				// grab the live file info if available
	   			
	   			if ( dm_state == DiskManager.CHECKING || dm_state == DiskManager.READY ){
	   			
	   				skeleton_files	= null;
	   			
	   				res = dm.getFiles();
	   			}
	   		}
	   		
	   		if ( res == null ){
	   			
	   			res = skeleton_files;
	   			
	   			if ( res == null ){

	   				res = DiskManagerFactory.getFileInfoSkeleton( download_manager );
	   				
	   				skeleton_files	= res;
	   			}
	   		}
	
	   		delegate = res[index];
		}
		
		public void 
		setPriority(
			boolean b )
		{
			fixup();
			
			delegate.setPriority(b);
		}
		
		public void 
		setSkipped(
			boolean b)
		{
			fixup();
			
			delegate.setSkipped(b);
		}
		 
		
		public boolean
		setLink(
			File	link_destination )
		{
			fixup();
		
			return( delegate.setLink( link_destination ));
		}
		
		public File
		getLink()
		{
			fixup();
			
			return( delegate.getLink());
		}
		
		public boolean
		setStorageType(
			int		type )
		{
			fixup();
			
			return( delegate.setStorageType( type ));
		}
		
		public int
		getStorageType()
		{
			fixup();
			
			return( delegate.getStorageType());
		}
		
		 	
		public int 
		getAccessMode()
		{
			fixup();
			
			return( delegate.getAccessMode());
		}
		
		public long 
		getDownloaded()
		{
			fixup();
			
			return( delegate.getDownloaded());
		}
		
		public String 
		getExtension()
		{
			fixup();
			
			return( delegate.getExtension());
		}
			
		public int 
		getFirstPieceNumber()
		{
			fixup();
			
			return( delegate.getFirstPieceNumber());
		}
	  
		public int 
		getLastPieceNumber()
		{
			fixup();
			
			return( delegate.getLastPieceNumber());
		}
		
		public long 
		getLength()
		{
			fixup();
			
			return( delegate.getLength());
		}
			
		public int 
		getNbPieces()
		{
			fixup();
			
			return( delegate.getNbPieces());
		}
				
		public boolean 
		isPriority()
		{
			fixup();
			
			return( delegate.isPriority());
		}
		
		public boolean 
		isSkipped()
		{
			fixup();
			
			return( delegate.isSkipped());
		}
		
		public int	
		getIndex()
		{
			fixup();
			
			return( delegate.getIndex());
		}
		
		public DiskManager 
		getDiskManager()
		{
			fixup();
			
			return( delegate.getDiskManager());
		}
		
		public File 
		getFile( boolean follow_link )
		{
			fixup();
			
			return( delegate.getFile( follow_link ));
		}
		
		public TOTorrentFile
		getTorrentFile()
		{
			fixup();
			
			return( delegate.getTorrentFile());
		}
		
		public void
		flushCache()
		
			throws	Exception
		{
			fixup();
			
			delegate.flushCache();
		}
	}
}