downloadmanagercontroller.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   DownloadManagerController.java

package org.gudy.azureus2.core3.download.impl;

import com.aelitis.azureus.core.AzureusCore;
import com.aelitis.azureus.core.AzureusCoreFactory;
import com.aelitis.azureus.core.networkmanager.LimitedRateGroup;
import com.aelitis.azureus.core.networkmanager.NetworkConnection;
import com.aelitis.azureus.core.peermanager.PeerManager;
import com.aelitis.azureus.core.peermanager.PeerManagerRegistration;
import com.aelitis.azureus.core.peermanager.PeerManagerRegistrationAdapter;
import com.aelitis.azureus.core.util.bloom.BloomFilter;
import com.aelitis.azureus.core.util.bloom.BloomFilterFactory;
import com.aelitis.azureus.plugins.extseed.ExternalSeedPlugin;
import java.io.File;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.gudy.azureus2.core3.config.COConfigurationManager;
import org.gudy.azureus2.core3.disk.DiskManager;
import org.gudy.azureus2.core3.disk.DiskManagerFactory;
import org.gudy.azureus2.core3.disk.DiskManagerFileInfo;
import org.gudy.azureus2.core3.disk.DiskManagerFileInfoListener;
import org.gudy.azureus2.core3.disk.DiskManagerFileInfoSet;
import org.gudy.azureus2.core3.disk.DiskManagerListener;
import org.gudy.azureus2.core3.disk.DiskManagerPiece;
import org.gudy.azureus2.core3.disk.DiskManagerReadRequest;
import org.gudy.azureus2.core3.disk.DiskManagerReadRequestListener;
import org.gudy.azureus2.core3.download.DownloadManager;
import org.gudy.azureus2.core3.download.DownloadManagerDiskListener;
import org.gudy.azureus2.core3.download.DownloadManagerState;
import org.gudy.azureus2.core3.download.DownloadManagerStats;
import org.gudy.azureus2.core3.download.ForceRecheckListener;
import org.gudy.azureus2.core3.global.GlobalManager;
import org.gudy.azureus2.core3.global.GlobalManagerStats;
import org.gudy.azureus2.core3.internat.MessageText;
import org.gudy.azureus2.core3.logging.LogEvent;
import org.gudy.azureus2.core3.logging.LogIDs;
import org.gudy.azureus2.core3.logging.LogRelation;
import org.gudy.azureus2.core3.logging.Logger;
import org.gudy.azureus2.core3.peer.PEPeer;
import org.gudy.azureus2.core3.peer.PEPeerManager;
import org.gudy.azureus2.core3.peer.PEPeerManagerAdapter;
import org.gudy.azureus2.core3.peer.PEPeerManagerFactory;
import org.gudy.azureus2.core3.peer.PEPeerManagerStats;
import org.gudy.azureus2.core3.peer.PEPeerSource;
import org.gudy.azureus2.core3.peer.PEPiece;
import org.gudy.azureus2.core3.torrent.TOTorrent;
import org.gudy.azureus2.core3.torrent.TOTorrentException;
import org.gudy.azureus2.core3.torrent.TOTorrentFile;
import org.gudy.azureus2.core3.tracker.client.TRTrackerAnnouncer;
import org.gudy.azureus2.core3.tracker.client.TRTrackerAnnouncerDataProvider;
import org.gudy.azureus2.core3.tracker.client.TRTrackerScraperResponse;
import org.gudy.azureus2.core3.util.AEMonitor;
import org.gudy.azureus2.core3.util.AESemaphore;
import org.gudy.azureus2.core3.util.Debug;
import org.gudy.azureus2.core3.util.DirectByteBuffer;
import org.gudy.azureus2.core3.util.FileUtil;
import org.gudy.azureus2.core3.util.IndentWriter;
import org.gudy.azureus2.core3.util.LightHashMap;
import org.gudy.azureus2.core3.util.ListenerManager;
import org.gudy.azureus2.core3.util.ListenerManagerDispatcher;
import org.gudy.azureus2.core3.util.NonDaemonTask;
import org.gudy.azureus2.core3.util.NonDaemonTaskRunner;
import org.gudy.azureus2.core3.util.SystemTime;
import org.gudy.azureus2.core3.util.TorrentUtils;
import org.gudy.azureus2.core3.util.UrlUtils;
import org.gudy.azureus2.plugins.PluginInterface;
import org.gudy.azureus2.plugins.PluginManager;
import org.gudy.azureus2.pluginsimpl.local.download.DownloadManagerImpl;

// Referenced classes of package org.gudy.azureus2.core3.download.impl:
//			DownloadManagerImpl, DownloadManagerStatsImpl

public class DownloadManagerController extends LogRelation
	implements PEPeerManagerAdapter, PeerManagerRegistrationAdapter
{
	protected class FileInfoFacadeSet
		implements DiskManagerFileInfoSet
	{

		DiskManagerFileInfoSet delegate;
		fileInfoFacade facadeFiles[];
		final DownloadManagerController this$0;

		public DiskManagerFileInfo[] getFiles()
		{
			return facadeFiles;
		}

		public int nbFiles()
		{
			if (delegate == null)
				return 0;
			else
				return delegate.nbFiles();
		}

		public void setPriority(boolean toChange[], boolean setPriority)
		{
			delegate.setPriority(toChange, setPriority);
		}

		public void setSkipped(boolean toChange[], boolean setSkipped)
		{
			delegate.setSkipped(toChange, setSkipped);
		}

		public boolean[] setStorageTypes(boolean toChange[], int newStroageType)
		{
			return delegate.setStorageTypes(toChange, newStroageType);
		}

		protected void fixupFileInfo(fileInfoFacade info[])
		{
			final List delayed_prio_changes;
			if (info.length == 0)
				return;
			delayed_prio_changes = new ArrayList();
			this_mon.enter();
			if (files_facade_destroyed)
			{
				this_mon.exit();
				return;
			}
			DiskManagerFileInfoSet active;
			final boolean initialising[];
			DiskManager dm = getDiskManager();
			active = null;
			if (dm != null)
			{
				int dm_state = dm.getState();
				if (dm_state == 3 || dm_state == 4)
					active = dm.getFileSet();
			}
			if (active != null)
				break MISSING_BLOCK_LABEL_197;
			initialising = (new boolean[] {
				true
			});
			DownloadManagerController.skeleton_builds++;
			if (DownloadManagerController.skeleton_builds % 1000L == 0L)
				Debug.outNoStack((new StringBuilder()).append("Skeleton builds: ").append(DownloadManagerController.skeleton_builds).toString());
			active = DiskManagerFactory.getFileInfoSkeleton(download_manager, new DiskManagerListener() {

				final boolean val$initialising[];
				final List val$delayed_prio_changes;
				final FileInfoFacadeSet this$1;

				public void stateChanged(int j, int k)
				{
				}

				public void filePriorityChanged(DiskManagerFileInfo file)
				{
					if (initialising[0])
						delayed_prio_changes.add(file);
					else
						download_manager.informPriorityChange(file);
				}

				public void pieceDoneChanged(DiskManagerPiece diskmanagerpiece)
				{
				}

				public void fileAccessModeChanged(DiskManagerFileInfo diskmanagerfileinfo, int j, int k)
				{
				}

				
				{
					this$1 = FileInfoFacadeSet.this;
					initialising = aflag;
					delayed_prio_changes = list;
					super();
				}
			});
			initialising[0] = false;
			break MISSING_BLOCK_LABEL_183;
			Exception exception;
			exception;
			initialising[0] = false;
			throw exception;
			calculateCompleteness(active.getFiles());
			DiskManagerFileInfo activeFiles[] = active.getFiles();
			for (int i = 0; i < info.length; i++)
				info[i].setDelegate(activeFiles[i]);

			delegate = active;
			this_mon.exit();
			break MISSING_BLOCK_LABEL_268;
			Exception exception1;
			exception1;
			this_mon.exit();
			throw exception1;
			fileFacadeSet.facadeFiles = info;
			download_manager.informPrioritiesChange(delayed_prio_changes);
			delayed_prio_changes.clear();
			return;
		}

		private void makeSureFilesFacadeFilled(boolean refresh)
		{
			if (!bInitialized)
				return;
			if (facadeFiles.length == 0)
			{
				fileInfoFacade newFacadeFiles[] = new fileInfoFacade[download_manager.getTorrent() != null ? download_manager.getTorrent().getFiles().length : 0];
				for (int i = 0; i < newFacadeFiles.length; i++)
					newFacadeFiles[i] = new fileInfoFacade();

				fileFacadeSet.fixupFileInfo(newFacadeFiles);
			} else
			if (refresh)
				fixupFileInfo(facadeFiles);
		}

		protected void destroyFileInfo()
		{
			this_mon.enter();
			if (fileFacadeSet == null || files_facade_destroyed)
			{
				this_mon.exit();
				return;
			}
			files_facade_destroyed = true;
			for (int i = 0; i < facadeFiles.length; i++)
				facadeFiles[i].close();

			this_mon.exit();
			break MISSING_BLOCK_LABEL_102;
			Exception exception;
			exception;
			this_mon.exit();
			throw exception;
		}


		protected FileInfoFacadeSet()
		{
			this$0 = DownloadManagerController.this;
			super();
			facadeFiles = new fileInfoFacade[0];
		}
	}

	protected class fileInfoFacade
		implements DiskManagerFileInfo
	{

		private DiskManagerFileInfo delegate;
		private List listeners;
		final DownloadManagerController this$0;

		protected void setDelegate(DiskManagerFileInfo _delegate)
		{
			if (_delegate == delegate)
				return;
			if (delegate != null)
				delegate.close();
			delegate = _delegate;
			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 boolean setLinkAtomic(File link_destination)
		{
			return delegate.setLinkAtomic(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
		{
			this_mon.enter();
			delegate.flushCache();
			this_mon.exit();
			break MISSING_BLOCK_LABEL_45;
			Exception exception;
			exception;
			this_mon.exit();
			throw exception;
		}

		public DirectByteBuffer read(long offset, int length)
			throws IOException
		{
			DirectByteBuffer directbytebuffer;
			this_mon.enter();
			directbytebuffer = delegate.read(offset, length);
			this_mon.exit();
			return directbytebuffer;
			Exception exception;
			exception;
			this_mon.exit();
			throw exception;
		}

		public void close()
		{
			this_mon.enter();
			delegate.close();
			this_mon.exit();
			break MISSING_BLOCK_LABEL_45;
			Exception exception;
			exception;
			this_mon.exit();
			throw exception;
		}

		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);
		}

		protected fileInfoFacade()
		{
			this$0 = DownloadManagerController.this;
			super();
		}
	}

	public class forceRecheckDiskManagerListener
		implements DiskManagerListener
	{

		private final boolean wasForceStarted;
		private final int start_state;
		private final ForceRecheckListener l;
		final DownloadManagerController this$0;

		public void stateChanged(int oldDMState, int newDMState)
		{
			this_mon.enter();
			if (getDiskManager() != null)
				break MISSING_BLOCK_LABEL_65;
			download_manager.setAssumedComplete(false);
			if (l != null)
				l.forceRecheckComplete(download_manager);
			this_mon.exit();
			return;
			this_mon.exit();
			break MISSING_BLOCK_LABEL_91;
			Exception e;
			e;
			this_mon.exit();
			throw e;
			if (newDMState == 3)
				fileFacadeSet.makeSureFilesFacadeFilled(true);
			if (newDMState != 4 && newDMState != 10)
				break MISSING_BLOCK_LABEL_470;
			force_start = wasForceStarted;
			stats.setDownloadCompleted(stats.getDownloadCompleted(true));
			if (newDMState != 4)
				break MISSING_BLOCK_LABEL_357;
			boolean only_seeding;
			boolean update_only_seeding;
			only_seeding = false;
			update_only_seeding = false;
			this_mon.enter();
			DiskManager dm = getDiskManager();
			if (dm != null)
			{
				dm.stop(false);
				only_seeding = dm.getRemainingExcludingDND() == 0L;
				update_only_seeding = true;