downloadmanagercontroller.java

java 文件下载器。可自定义

				setDiskManager(null, null);
				if (start_state == 100)
					setState(70, false);
				else
					setState(start_state, false);
			}
			this_mon.exit();
			download_manager.informStateChanged();
			break MISSING_BLOCK_LABEL_305;
			Exception exception;
			exception;
			this_mon.exit();
			download_manager.informStateChanged();
			throw exception;
			if (update_only_seeding)
				download_manager.setAssumedComplete(only_seeding);
			break MISSING_BLOCK_LABEL_447;
			only_seeding;
			setFailed((new StringBuilder()).append("Resume data save fails: ").append(Debug.getNestedExceptionMessage(only_seeding)).toString());
			break MISSING_BLOCK_LABEL_447;
			this_mon.enter();
			DiskManager dm = getDiskManager();
			if (dm != null)
			{
				dm.stop(false);
				setDiskManager(null, null);
				setFailed(dm.getErrorMessage());
			}
			this_mon.exit();
			break MISSING_BLOCK_LABEL_436;
			Exception exception1;
			exception1;
			this_mon.exit();
			throw exception1;
			download_manager.setAssumedComplete(false);
			if (l != null)
				l.forceRecheckComplete(download_manager);
		}

		public void filePriorityChanged(DiskManagerFileInfo file)
		{
			download_manager.informPriorityChange(file);
		}

		public void pieceDoneChanged(DiskManagerPiece diskmanagerpiece)
		{
		}

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

		public forceRecheckDiskManagerListener(boolean wasForceStarted, int start_state, ForceRecheckListener l)
		{
			this$0 = DownloadManagerController.this;
			super();
			this.wasForceStarted = wasForceStarted;
			this.start_state = start_state;
			this.l = l;
		}
	}


	private static long STATE_FLAG_HASDND = 1L;
	private static long STATE_FLAG_COMPLETE_NO_DND = 2L;
	private static long skeleton_builds;
	private static ExternalSeedPlugin ext_seed_plugin;
	private static boolean ext_seed_plugin_tried;
	private static final int LDT_DL_ADDED = 1;
	private static final int LDT_DL_REMOVED = 2;
	private static ListenerManager disk_listeners_agregator = ListenerManager.createAsyncManager("DMC:DiskListenAgregatorDispatcher", new ListenerManagerDispatcher() {

		public void dispatch(Object _listener, int type, Object value)
		{
			DownloadManagerDiskListener listener = (DownloadManagerDiskListener)_listener;
			if (type == 1)
				listener.diskManagerAdded((DiskManager)value);
			else
			if (type == 2)
				listener.diskManagerRemoved((DiskManager)value);
		}

	});
	private ListenerManager disk_listeners;
	private AEMonitor disk_listeners_mon;
	protected AEMonitor this_mon;
	protected AEMonitor state_mon;
	private org.gudy.azureus2.core3.download.impl.DownloadManagerImpl download_manager;
	private DownloadManagerStatsImpl stats;
	private volatile int state_set_by_method;
	private volatile int substate;
	private volatile boolean force_start;
	private volatile DiskManager disk_manager_use_accessors;
	private DiskManagerListener disk_manager_listener_use_accessors;
	private FileInfoFacadeSet fileFacadeSet;
	private boolean files_facade_destroyed;
	private boolean cached_complete_excluding_dnd;
	private boolean cached_has_dnd_files;
	private boolean cached_values_set;
	private PeerManagerRegistration peer_manager_registration;
	private PEPeerManager peer_manager;
	private List external_rate_limiters_cow;
	private String errorDetail;
	private GlobalManagerStats global_stats;
	private boolean bInitialized;
	private long data_send_rate_at_close;
	private static final int ACTIVATION_REBUILD_TIME = 0x927c0;
	private static final int BLOOM_SIZE = 64;
	private volatile BloomFilter activation_bloom;
	private volatile long activation_bloom_create_time;
	private volatile int activation_count;
	private volatile long activation_count_time;
	private boolean piece_checking_enabled;
	private long priority_connection_count;

	private static ExternalSeedPlugin getExternalSeedPlugin()
	{
		if (!ext_seed_plugin_tried)
		{
			ext_seed_plugin_tried = true;
			try
			{
				PluginInterface ext_pi = AzureusCoreFactory.getSingleton().getPluginManager().getPluginInterfaceByClass(com/aelitis/azureus/plugins/extseed/ExternalSeedPlugin);
				if (ext_pi != null)
					ext_seed_plugin = (ExternalSeedPlugin)ext_pi.getPlugin();
			}
			catch (Throwable e)
			{
				Debug.printStackTrace(e);
			}
		}
		return ext_seed_plugin;
	}

	protected DownloadManagerController(org.gudy.azureus2.core3.download.impl.DownloadManagerImpl _download_manager)
	{
		disk_listeners = ListenerManager.createManager("DMC:DiskListenDispatcher", new ListenerManagerDispatcher() {

			final DownloadManagerController this$0;

			public void dispatch(Object listener, int type, Object value)
			{
				DownloadManagerController.disk_listeners_agregator.dispatch(listener, type, value);
			}

			
			{
				this$0 = DownloadManagerController.this;
				super();
			}
		});
		disk_listeners_mon = new AEMonitor("DownloadManagerController:DL");
		this_mon = new AEMonitor("DownloadManagerController");
		state_mon = new AEMonitor("DownloadManagerController:State");
		state_set_by_method = -1;
		fileFacadeSet = new FileInfoFacadeSet();
		bInitialized = false;
		activation_bloom_create_time = SystemTime.getCurrentTime();
		piece_checking_enabled = true;
		download_manager = _download_manager;
		GlobalManager gm = download_manager.getGlobalManager();
		global_stats = gm.getStats();
		stats = (DownloadManagerStatsImpl)download_manager.getStats();
		cached_values_set = false;
	}

	protected void setInitialState(int initial_state)
	{
		bInitialized = true;
		if (getState() == -1)
			setState(initial_state, true);
		TOTorrent torrent = download_manager.getTorrent();
		if (torrent != null)
			try
			{
				peer_manager_registration = PeerManager.getSingleton().registerLegacyManager(torrent.getHashWrapper(), this);
			}
			catch (TOTorrentException e)
			{
				Debug.printStackTrace(e);
			}
		DownloadManagerState state = download_manager.getDownloadState();
		if (state.parameterExists("dndflags"))
		{
			long flags = state.getLongParameter("dndflags");
			cached_complete_excluding_dnd = (flags & STATE_FLAG_COMPLETE_NO_DND) != 0L;
			cached_has_dnd_files = (flags & STATE_FLAG_HASDND) != 0L;
			cached_values_set = true;
		}
	}

	public void startDownload(TRTrackerAnnouncer tracker_client)
	{
		this_mon.enter();
		if (getState() == 40)
			break MISSING_BLOCK_LABEL_75;
		Debug.out((new StringBuilder()).append("DownloadManagerController::startDownload state must be ready, ").append(getState()).toString());
		setFailed((new StringBuilder()).append("Inconsistent download state: startDownload, state = ").append(getState()).toString());
		this_mon.exit();
		return;
		if (tracker_client != null)
			break MISSING_BLOCK_LABEL_100;
		Debug.out("DownloadManagerController:startDownload: tracker_client is null");
		stopIt(70, false, false);
		this_mon.exit();
		return;
		DiskManager dm;
		if (peer_manager != null)
		{
			Debug.out("DownloadManagerController::startDownload: peer manager not null");
			peer_manager.stopAll();
			peer_manager = null;
		}
		dm = getDiskManager();
		if (dm != null)
			break MISSING_BLOCK_LABEL_148;
		Debug.out("DownloadManagerController::startDownload: disk manager is null");
		this_mon.exit();
		return;
		setState(50, false);
		this_mon.exit();
		break MISSING_BLOCK_LABEL_175;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
		final PEPeerManager temp;
		temp = PEPeerManagerFactory.create(tracker_client.getPeerId(), this, dm);
		download_manager.informWillBeStarted(temp);
		temp.start();
		tracker_client.setAnnounceDataProvider(new TRTrackerAnnouncerDataProvider() {

			private long last_reported_total_received;
			private long last_reported_total_received_data;
			private long last_reported_total_received_discard;
			private long last_reported_total_received_failed;
			final PEPeerManager val$temp;
			final DownloadManagerController this$0;

			public String getName()
			{
				return getDisplayName();
			}

			public long getTotalSent()
			{
				return temp.getStats().getTotalDataBytesSent();
			}

			public long getTotalReceived()
			{
				long received = temp.getStats().getTotalDataBytesReceived();
				long discarded = temp.getStats().getTotalDiscarded();
				long failed = temp.getStats().getTotalHashFailBytes();
				long verified = received - (discarded + failed);
				verified -= temp.getHiddenBytes();
				if (verified < last_reported_total_received)
				{
					verified = last_reported_total_received;
					if (last_reported_total_received_data != -1L)
						last_reported_total_received_data = -1L;
				} else
				{
					last_reported_total_received = verified;
					last_reported_total_received_data = received;
					last_reported_total_received_discard = discarded;
					last_reported_total_received_failed = failed;
				}
				return verified >= 0L ? verified : 0L;
			}

			public long getRemaining()
			{
				return Math.max(temp.getRemaining(), temp.getHiddenBytes());
			}

			public long getFailedHashCheck()
			{
				return temp.getStats().getTotalHashFailBytes();
			}

			public String getExtensions()
			{
				return getTrackerClientExtensions();
			}

			public int getMaxNewConnectionsAllowed()
			{
				return temp.getMaxNewConnectionsAllowed();
			}

			public int getUploadSpeedKBSec(boolean estimate)
			{
				long current_local = stats.getDataSendRate();
				if (estimate)
				{
					current_local = data_send_rate_at_close;
					if (current_local == 0L)
					{
						int current_global = global_stats.getDataSendRate();
						int old_global = global_stats.getDataSendRateAtClose();
						if (current_global < old_global)
							current_global = old_global;
						List managers = download_manager.getGlobalManager().getDownloadManagers();
						int num_dls = 0;
						for (int i = 0; i < managers.size(); i++)
						{
							DownloadManager dm = (DownloadManager)managers.get(i);
							if (dm.getStats().getDownloadCompleted(false) == 1000)
								continue;
							int state = dm.getState();
							if (state != 100 && state != 65 && state != 70)
								num_dls++;
						}

						if (num_dls == 0)
							current_local = current_global;
						else
							current_local = current_global / num_dls;
					}
				}
				return (int)((current_local + 1023L) / 1024L);
			}

			public int getCryptoLevel()
			{
				return download_manager.getCryptoLevel();
			}

			public void setPeerSources(String allowed_sources[])
			{
				DownloadManagerState dms = download_manager.getDownloadState();
				String sources[] = PEPeerSource.PS_SOURCES;
				for (int i = 0; i < sources.length; i++)
				{
					String s = sources[i];
					boolean ok = false;
					int j = 0;
					do
					{
						if (j >= allowed_sources.length)
							break;
						if (s.equals(allowed_sources[j]))
						{
							ok = true;
							break;
						}
						j++;
					} while (true);
					if (!ok)
						dms.setPeerSourcePermitted(s, false);
				}

				PEPeerManager pm = getPeerManager();
				if (pm != null)
				{
					Set allowed = new HashSet();
					allowed.addAll(Arrays.asList(allowed_sources));
					Iterator it = pm.getPeers().iterator();
					do
					{
						if (!it.hasNext())
							break;
						PEPeer peer = (PEPeer)it.next();
						if (!allowed.contains(peer.getPeerSource()))
							pm.removePeer(peer, "Peer source not permitted");
					} while (true);
				}
			}

			public boolean isPeerSourceEnabled(String peer_source)
			{
				return DownloadManagerController.this.isPeerSourceEnabled(peer_source);
			}

			
			{
				this$0 = DownloadManagerController.this;
				temp = pepeermanager;
				super();
			}
		});
		List limiters;
		this_mon.enter();
		peer_manager = temp;
		limiters = external_rate_limiters_cow;
		this_mon.exit();
		break MISSING_BLOCK_LABEL_256;
		Exception exception1;
		exception1;
		this_mon.exit();
		throw exception1;
		if (limiters != null)
		{
			for (int i = 0; i < limiters.size(); i++)
			{
				Object entry[] = (Object[])(Object[])limiters.get(i);
				temp.addRateLimiter((LimitedRateGroup)entry[0], ((Boolean)entry[1]).booleanValue());
			}

		}
		if (getState() == 50)
			download_manager.informStateChanged();
		download_manager.informStarted(temp);
		return;
	}

	public void initializeDiskManager(final boolean open_for_seeding)
	{
		initializeDiskManagerSupport(10, new DiskManagerListener() {

			final boolean val$open_for_seeding;
			final DownloadManagerController this$0;

			public void stateChanged(int oldDMState, int newDMState)
			{
				DiskManager dm;
				this_mon.enter();
				dm = getDiskManager();
				if (dm == null)
				{
					this_mon.exit();
					return;
				}
				this_mon.exit();
				break MISSING_BLOCK_LABEL_61;
				Exception exception;
				exception;
				this_mon.exit();
				throw exception;
				if (newDMState == 10)
					setFailed(dm.getErrorMessage());
				if (oldDMState == 3 && newDMState != 3)
				{
					fileFacadeSet.makeSureFilesFacadeFilled(true);
					stats.setDownloadCompleted(stats.getDownloadCompleted(true));
					download_manager.setAssumedComplete(isDownloadComplete(false));
				}
				if (newDMState == 4)
				{
					int completed = stats.getDownloadCompleted(false);
					if (stats.getTotalDataBytesReceived() == 0L && stats.getTotalDataBytesSent() == 0L && stats.getSecondsDownloading() == 0L)
						if (completed < 1000)
						{
							if (open_for_seeding)
							{
								setFailed("File check failed");
								download_manager.getDownloadState().clearResumeData();
							} else
							{
								long amount_downloaded = ((long)completed * dm.getTotalLength()) / 1000L;
								stats.setSavedDownloadedUploaded(amount_downloaded, amount_downloaded);
							}
						} else
						{
							int dl_copies = COConfigurationManager.getIntParameter("StartStopManager_iAddForSeedingDLCopyCount");
							if (dl_copies > 0)
								stats.setSavedDownloadedUploaded(download_manager.getSize() * (long)dl_copies, stats.getTotalDataBytesSent());
							download_manager.getDownloadState().setFlag(1L, true);
						}
					if (completed == 1000)
						download_manager.getDownloadState().discardFluff();
				}
				download_manager.informStateChanged();
				break MISSING_BLOCK_LABEL_392;
				Exception exception1;
				exception1;
				download_manager.informStateChanged();
				throw exception1;
			}

			public void filePriorityChanged(DiskManagerFileInfo file)
			{
				download_manager.informPriorityChange(file);
			}

			public void pieceDoneChanged(DiskManagerPiece diskmanagerpiece)
			{
			}

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

			
			{
				this$0 = DownloadManagerController.this;
				open_for_seeding = flag;
				super();