downloadmanagercontroller.java

这是一个基于java编写的torrent的P2P源码

	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(
		PEPeer		peer,
		int			bytes )
	{
		if ( global_stats != null ){
			
			global_stats.discarded( bytes );
		}
	}
	
	public void
	protocolBytesReceived(
		PEPeer		peer,
		int			bytes )
	{
		if ( global_stats != null ){
			
			global_stats.protocolBytesReceived( bytes );
		}
	}
	
	public void
	dataBytesReceived(
		PEPeer		peer,
		int			bytes )
	{
		if ( global_stats != null ){
			
			global_stats.dataBytesReceived( bytes );
		}
	}
	
	public void
	protocolBytesSent(
		PEPeer		peer,
		int			bytes )
	{
		if ( global_stats != null ){
			
			global_stats.protocolBytesSent( bytes, peer.isLANLocal());
		}
	}
	
	public void
	dataBytesSent(
		PEPeer		peer,
		int			bytes )
	{
		if ( global_stats != null ){
			
			global_stats.dataBytesSent( bytes, peer.isLANLocal());
		}
	}
	
	public void
	addHTTPSeed(
		String	address,
		int		port )
	{
		ExternalSeedPlugin	plugin = getExternalSeedPlugin();

		try{
			if ( plugin != null ){
				
				Map config = new HashMap();
	
				List urls = new ArrayList();
				
				String	seed_url = "http://" + address + ":" + port + "/webseed";
				
				urls.add( seed_url.getBytes());
	
				config.put("httpseeds", urls);
	
				Map params = new HashMap();
	
				params.put( "supports_503", new Long(0));
				params.put( "transient", new Long(1));
	
				config.put("httpseeds-params", params);
	
				plugin.addSeed( org.gudy.azureus2.pluginsimpl.local.download.DownloadManagerImpl.getDownloadStatic( download_manager ), config);
			}
		}catch( Throwable e ){
			
			Debug.printStackTrace(e);
		}
	}
	
	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 void
	destroyFileInfo()
	{
		try{
			facade_mon.enter();

			if ( files_facade == null || files_facade_destroyed ){
				
				return;
			}
			
			files_facade_destroyed = true;
			
			for (int i=0;i<files_facade.length;i++){
				
				files_facade[i].close();
			}
		}finally{
			
			facade_mon.exit();
		}
	}
	
	/** XXX Don't call me, call makeSureFilesFacadeFilled() */
	protected void
	fixupFileInfo(
		fileInfoFacade[]	info )
	{
		if ( info.length == 0 ){
		
				// too early in initialisation sequence to action this - it'll get reinvoked later anyway
			
			return;
		}
		
		final List	delayed_prio_changes = new ArrayList();

		try{
			facade_mon.enter();
				
			if ( files_facade_destroyed ){
				
				return;
			}
			
			DiskManager	dm = DownloadManagerController.this.getDiskManager();

			DiskManagerFileInfo[]	active	= 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 ){
   			  			
					active = dm.getFiles();
				}
   			}
   		
			if ( active == null ){
   		  					
	   			final boolean[]	initialising = { true };
	   				
   					// chance of recursion with this listener as the file-priority-changed is triggered
   					// synchronously during construction and this can cause a listener to reenter the
   					// incomplete fixup logic here + instantiate new skeletons.....
   				
	   			try{
	   				skeleton_builds++;
	   				
	   				if ( skeleton_builds % 1000 == 0 ){
	   					
	   					Debug.outNoStack( "Skeleton builds: " + skeleton_builds );
	   				}
	   				
	   				active = DiskManagerFactory.getFileInfoSkeleton( 
							download_manager,
							new DiskManagerListener()
							{
								public void
								stateChanged(
									int oldState, 
									int	newState )
								{
								}
								
								public void
								filePriorityChanged(
									DiskManagerFileInfo		file )
								{
									if ( initialising[0] ){
										
										delayed_prio_changes.add( file );
										
									}else{
										
										download_manager.informPriorityChange( file );
									}
								}
	
								public void
								pieceDoneChanged(
									DiskManagerPiece		piece )
								{
								}
								
								public void
								fileAccessModeChanged(
									DiskManagerFileInfo		file,
									int						old_mode,
									int						new_mode )
								{
								}
							});
	   			}finally{
	   				
	   				initialising[0]	= false;
	   			}
	   			
	   			calculateCompleteness( active );
			}
   
			for (int i=0;i<info.length;i++){
				
				info[i].setDelegate( active[i] );
			}
		}finally{
   				
   			facade_mon.exit();
   		}
   			
		files_facade	= info;
		
   		for (int i=0;i<delayed_prio_changes.size();i++){
   					
   			download_manager.informPriorityChange((DiskManagerFileInfo)delayed_prio_changes.get(i));
   		}
   				
   		delayed_prio_changes.clear();
	}
	
	protected class
	fileInfoFacade
		implements DiskManagerFileInfo
	{
		private DiskManagerFileInfo		delegate;
		
		private List					listeners;
		
		protected 
		fileInfoFacade()
		{
		}
		
		protected void
		setDelegate(
			DiskManagerFileInfo		_delegate )
		{
			if ( _delegate == delegate ){
				
				return;
			}
			
			if ( delegate != null ){
				
				delegate.close();
			}

	 		delegate = _delegate;
	   		
	 			// transfer any existing listeners across
	 		
	   		if ( listeners != null ){
	   			
	   			for (int i=0;i<listeners.size();i++){
	   				
	   				delegate.addListener((DiskManagerFileInfoListener)listeners.get(i));
	   			}
	   		}
		}

		public void 
		setPriority(
			boolean b )
		{
			delegate.setPriority(b);
		}
		
		public void 
		setSkipped(
			boolean b)
		{
			delegate.setSkipped(b);
		}
		 
		
		public boolean
		setLink(
			File	link_destination )
		{
			return( delegate.setLink( link_destination ));
		}
		
		public File
		getLink()
		{
			return( delegate.getLink());
		}
		
		public boolean
		setStorageType(
			int		type )
		{
			return( delegate.setStorageType( type ));
		}
		
		public int
		getStorageType()
		{
			return( delegate.getStorageType());
		}
		
		 	
		public int 
		getAccessMode()
		{
			return( delegate.getAccessMode());
		}
		
		public long 
		getDownloaded()
		{
			return( delegate.getDownloaded());
		}
		
		public String 
		getExtension()
		{
			return( delegate.getExtension());
		}
			
		public int 
		getFirstPieceNumber()
		{
			return( delegate.getFirstPieceNumber());
		}
	  
		public int 
		getLastPieceNumber()
		{
			return( delegate.getLastPieceNumber());
		}
		
		public long 
		getLength()
		{
			return( delegate.getLength());
		}
			
		public int 
		getNbPieces()
		{
			return( delegate.getNbPieces());
		}
				
		public boolean 
		isPriority()
		{
			return( delegate.isPriority());
		}
		
		public boolean 
		isSkipped()
		{
			return( delegate.isSkipped());
		}
		
		public int	
		getIndex()
		{
			return( delegate.getIndex());
		}
		
		public DiskManager 
		getDiskManager()
		{
			return( delegate.getDiskManager());
		}
		
		public DownloadManager	
		getDownloadManager()
		{
			return( download_manager );
		}
		
		public File 
		getFile( boolean follow_link )
		{
			return( delegate.getFile( follow_link ));
		}
		
		public TOTorrentFile
		getTorrentFile()
		{
			return( delegate.getTorrentFile());
		}
		
		public void
		flushCache()
		
			throws	Exception
		{
			delegate.flushCache();
		}
		
		public DirectByteBuffer
		read(
			long	offset,
			int		length )
		
			throws IOException
		{
			return( delegate.read( offset, length ));
		}
		
		public void
		close()
		{
			delegate.close();
		}
		
		public void
		addListener(
			DiskManagerFileInfoListener	listener )
		{
			if ( listeners == null ){
				
				listeners = new ArrayList();
			}
			
			listeners.add( listener );
			
			delegate.addListener( listener );
		}
		
		public void
		removeListener(
			DiskManagerFileInfoListener	listener )
		{
			listeners.remove( listener );
			
			delegate.removeListener( listener );
		}
	}
	
	public void generateEvidence(IndentWriter writer) {
		writer.println("DownloadManager Controller:");
		
		writer.indent();
		try {
			writer.println("cached info: complete w/o DND="
					+ cached_complete_excluding_dnd + "; hasDND? " + cached_has_dnd_files);

			writer.println("Complete w/DND? " + isDownloadComplete(true)
					+ "; w/o DND? " + isDownloadComplete(false));

			writer.println("filesFacade length: " + files_facade.length);

			if (force_start) {
				writer.println("Force Start");
			}

			writer.println("FilesExist? " + filesExist());
			
		} finally {
			writer.exdent();
		}
	}
}