downloadmanagerimpl.java

java 文件下载器。可自定义

		Debug.printStackTrace(e);
		if (true) goto _L2; else goto _L1
_L1:
		return false;
	}

	public int getActivationCount()
	{
		return controller.getActivationCount();
	}

	public String getTorrentComment()
	{
		return torrent_comment;
	}

	public String getTorrentCreatedBy()
	{
		return torrent_created_by;
	}

	public long getTorrentCreationDate()
	{
		if (torrent == null)
			return 0L;
		else
			return torrent.getCreationDate();
	}

	public GlobalManager getGlobalManager()
	{
		return globalManager;
	}

	public DiskManager getDiskManager()
	{
		return controller.getDiskManager();
	}

	public DiskManagerFileInfoSet getDiskManagerFileInfoSet()
	{
		return controller.getDiskManagerFileInfoSet();
	}

	public DiskManagerFileInfo[] getDiskManagerFileInfo()
	{
		return controller.getDiskManagerFileInfo();
	}

	public PEPeerManager getPeerManager()
	{
		return controller.getPeerManager();
	}

	public boolean isDownloadComplete(boolean bIncludeDND)
	{
		if (!bIncludeDND)
			return assumedComplete;
		else
			return controller.isDownloadComplete(bIncludeDND);
	}

	public void addListener(DownloadManagerListener listener)
	{
		addListener(listener, true);
	}

	public void addListener(DownloadManagerListener listener, boolean triggerStateChange)
	{
		if (listener == null)
		{
			Debug.out("Warning: null listener");
			return;
		}
		listeners_mon.enter();
		listeners.addListener(listener);
		if (triggerStateChange)
			listener.stateChanged(this, getState());
		listeners_mon.exit();
		break MISSING_BLOCK_LABEL_81;
		Throwable t;
		t;
		Debug.out("adding listener", t);
		listeners_mon.exit();
		break MISSING_BLOCK_LABEL_81;
		Exception exception;
		exception;
		listeners_mon.exit();
		throw exception;
	}

	public void removeListener(DownloadManagerListener listener)
	{
		listeners_mon.enter();
		listeners.removeListener(listener);
		listeners_mon.exit();
		break MISSING_BLOCK_LABEL_35;
		Exception exception;
		exception;
		listeners_mon.exit();
		throw exception;
	}

	protected void informStateChanged()
	{
		listeners_mon.enter();
		int new_state = controller.getState();
		boolean new_force_start = controller.isForceStart();
		if (new_state != last_informed_state || new_force_start != latest_informed_force_start)
		{
			last_informed_state = new_state;
			latest_informed_force_start = new_force_start;
			listeners.dispatch(1, ((Object) (new Object[] {
				this, new Integer(new_state)
			})));
		}
		listeners_mon.exit();
		break MISSING_BLOCK_LABEL_96;
		Exception exception;
		exception;
		listeners_mon.exit();
		throw exception;
	}

	protected void informDownloadEnded()
	{
		listeners_mon.enter();
		listeners.dispatch(2, ((Object) (new Object[] {
			this
		})));
		listeners_mon.exit();
		break MISSING_BLOCK_LABEL_43;
		Exception exception;
		exception;
		listeners_mon.exit();
		throw exception;
	}

	void informPrioritiesChange(List files)
	{
		controller.filePrioritiesChanged(files);
		listeners_mon.enter();
		for (int i = 0; i < files.size(); i++)
			listeners.dispatch(5, ((Object) (new Object[] {
				this, (DiskManagerFileInfo)files.get(i)
			})));

		listeners_mon.exit();
		break MISSING_BLOCK_LABEL_82;
		Exception exception;
		exception;
		listeners_mon.exit();
		throw exception;
		requestAssumedCompleteMode();
		return;
	}

	protected void informPriorityChange(DiskManagerFileInfo file)
	{
		informPrioritiesChange(Collections.singletonList(file));
	}

	protected void informPositionChanged(int new_position)
	{
		listeners_mon.enter();
		int old_position = position;
		if (new_position != old_position)
		{
			position = new_position;
			listeners.dispatch(4, ((Object) (new Object[] {
				this, new Integer(old_position), new Integer(new_position)
			})));
			if (getState() == 60 || getState() == 50)
				PeerControlSchedulerFactory.getSingleton().updateScheduleOrdering();
		}
		listeners_mon.exit();
		break MISSING_BLOCK_LABEL_106;
		Exception exception;
		exception;
		listeners_mon.exit();
		throw exception;
	}

	public void addPeerListener(DownloadManagerPeerListener listener)
	{
		addPeerListener(listener, true);
	}

	public void addPeerListener(DownloadManagerPeerListener listener, boolean bDispatchForExisting)
	{
		peer_listeners_mon.enter();
		peer_listeners.addListener(listener);
		if (!bDispatchForExisting)
		{
			peer_listeners_mon.exit();
			return;
		}
		for (int i = 0; i < current_peers.size(); i++)
			peer_listeners.dispatch(listener, 1, current_peers.get(i));

		PEPeerManager temp = controller.getPeerManager();
		if (temp != null)
			peer_listeners.dispatch(listener, 5, temp);
		peer_listeners_mon.exit();
		break MISSING_BLOCK_LABEL_111;
		Exception exception;
		exception;
		peer_listeners_mon.exit();
		throw exception;
	}

	public void removePeerListener(DownloadManagerPeerListener listener)
	{
		peer_listeners.removeListener(listener);
	}

	public void addPieceListener(DownloadManagerPieceListener listener)
	{
		addPieceListener(listener, true);
	}

	public void addPieceListener(DownloadManagerPieceListener listener, boolean bDispatchForExisting)
	{
		piece_listeners_mon.enter();
		piece_listeners.addListener(listener);
		if (!bDispatchForExisting)
		{
			piece_listeners_mon.exit();
			return;
		}
		for (int i = 0; i < current_pieces.size(); i++)
			piece_listeners.dispatch(listener, 3, current_pieces.get(i));

		piece_listeners_mon.exit();
		break MISSING_BLOCK_LABEL_89;
		Exception exception;
		exception;
		piece_listeners_mon.exit();
		throw exception;
	}

	public void removePieceListener(DownloadManagerPieceListener listener)
	{
		piece_listeners.removeListener(listener);
	}

	public void addPeer(PEPeer peer)
	{
		peer_listeners_mon.enter();
		current_peers.add(peer);
		peer_listeners.dispatch(1, peer);
		peer_listeners_mon.exit();
		break MISSING_BLOCK_LABEL_47;
		Exception exception;
		exception;
		peer_listeners_mon.exit();
		throw exception;
	}

	public void removePeer(PEPeer peer)
	{
		peer_listeners_mon.enter();
		current_peers.remove(peer);
		peer_listeners.dispatch(2, peer);
		peer_listeners_mon.exit();
		break MISSING_BLOCK_LABEL_47;
		Exception exception;
		exception;
		peer_listeners_mon.exit();
		throw exception;
		if ((peer.isSeed() || peer.isRelativeSeed()) && isDownloadComplete(false))
		{
			TRTrackerAnnouncer announcer = tracker_client;
			if (announcer != null)
				announcer.removeFromTrackerResponseCache(peer.getIp(), peer.getTCPListenPort());
		}
		return;
	}

	public PEPeer[] getCurrentPeers()
	{
		PEPeer apepeer[];
		peer_listeners_mon.enter();
		apepeer = (PEPeer[])(PEPeer[])current_peers.toArray(new PEPeer[current_peers.size()]);
		peer_listeners_mon.exit();
		return apepeer;
		Exception exception;
		exception;
		peer_listeners_mon.exit();
		throw exception;
	}

	public void addPiece(PEPiece piece)
	{
		piece_listeners_mon.enter();
		current_pieces.add(piece);
		piece_listeners.dispatch(3, piece);
		piece_listeners_mon.exit();
		break MISSING_BLOCK_LABEL_47;
		Exception exception;
		exception;
		piece_listeners_mon.exit();
		throw exception;
	}

	public void removePiece(PEPiece piece)
	{
		piece_listeners_mon.enter();
		current_pieces.remove(piece);
		piece_listeners.dispatch(4, piece);
		piece_listeners_mon.exit();
		break MISSING_BLOCK_LABEL_47;
		Exception exception;
		exception;
		piece_listeners_mon.exit();
		throw exception;
	}

	public PEPiece[] getCurrentPieces()
	{
		PEPiece apepiece[];
		piece_listeners_mon.enter();
		apepiece = (PEPiece[])(PEPiece[])current_pieces.toArray(new PEPiece[current_pieces.size()]);
		piece_listeners_mon.exit();
		return apepiece;
		Exception exception;
		exception;
		piece_listeners_mon.exit();
		throw exception;
	}

	protected void informWillBeStarted(PEPeerManager pm)
	{
		List l = peer_listeners.getListenersCopy();
		for (int i = 0; i < l.size(); i++)
			try
			{
				((DownloadManagerPeerListener)l.get(i)).peerManagerWillBeAdded(pm);
			}
			catch (Throwable e)
			{
				Debug.printStackTrace(e);
			}

	}

	protected void informStarted(PEPeerManager pm)
	{
		peer_listeners_mon.enter();
		peer_listeners.dispatch(5, pm);
		peer_listeners_mon.exit();
		break MISSING_BLOCK_LABEL_36;
		Exception exception;
		exception;
		peer_listeners_mon.exit();
		throw exception;
		TRTrackerAnnouncer tc = getTrackerClient();
		if (tc != null)
			tc.update(true);
		return;
	}

	protected void informStopped(PEPeerManager pm, boolean for_queue)
	{
		if (pm == null)
			break MISSING_BLOCK_LABEL_41;
		peer_listeners_mon.enter();
		peer_listeners.dispatch(6, pm);
		peer_listeners_mon.exit();
		break MISSING_BLOCK_LABEL_41;
		Exception exception;
		exception;
		peer_listeners_mon.exit();
		throw exception;
		this_mon.enter();
		if (tracker_client != null)
		{
			tracker_client.addListener(stopping_tracker_client_listener);
			tracker_client.removeListener(tracker_client_listener);
			download_manager_state.setTrackerResponseCache(tracker_client.getTrackerResponseCache());
			tracker_client.getLastResponse().setPeers(new TRTrackerAnnouncerResponsePeer[0]);
			tracker_client.stop(for_queue && isDownloadComplete(false));
			tracker_client.destroy();
			tracker_client = null;
		}
		this_mon.exit();
		break MISSING_BLOCK_LABEL_179;
		Exception exception1;
		exception1;
		this_mon.exit();
		throw exception1;
	}

	public DownloadManagerStats getStats()
	{
		return stats;
	}

	public boolean isForceStart()
	{
		return controller.isForceStart();
	}

	public void setForceStart(boolean forceStart)
	{
		controller.setForceStart(forceStart);
	}

	protected void downloadEnded(boolean never_downloaded)
	{
		if (!never_downloaded)
		{
			if (isForceStart())
				setForceStart(false);
			setAssumedComplete(true);
			informDownloadEnded();
		}
		TRTrackerAnnouncer tc = tracker_client;
		if (tc != null)
		{
			DiskManager dm = getDiskManager();
			if (dm != null && dm.getRemaining() == 0L)
				tc.complete(never_downloaded);
		}
	}

	public void addDiskListener(DownloadManagerDiskListener listener)
	{
		controller.addDiskListener(listener);
	}

	public void removeDiskListener(DownloadManagerDiskListener listener)
	{
		controller.removeDiskListener(listener);
	}

	public void addActivationListener(DownloadManagerActivationListener listener)
	{
		activation_listeners.add(listener);
	}

	public void removeActivationListener(DownloadManagerActivationListener listener)
	{
		activation_listeners.remove(listener);
	}

	public int getHealthStatus()
	{
		int state = getState();
		PEPeerManager peerManager = controller.getPeerManager();
		TRTrackerAnnouncer tc = getTrackerClient();
		if (tc != null && peerManager != null && (state == 50 || state == 60))
		{
			int nbSeeds = getNbSeeds();
			int nbPeers = getNbPeers();
			int nbRemotes = peerManager.getNbRemoteConnectionsExcludingUDP();
			TRTrackerAnnouncerResponse announce_response = tc.getLastResponse();
			int trackerStatus = announce_response.getStatus();
			boolean isSeed = state == 60;
			if (nbSeeds + nbPeers == 0)
				return !isSeed ? 5 : 2;
			if (!isSeed && (trackerStatus == 0 || trackerStatus == 1))
				return 2;
			if (nbRemotes == 0)
			{
				TRTrackerScraperResponse scrape_response = getTrackerScrapeResponse();