peerforeigndelegate.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:   PeerForeignDelegate.java

package org.gudy.azureus2.pluginsimpl.local.peers;

import com.aelitis.azureus.core.networkmanager.*;
import com.aelitis.azureus.core.peermanager.messaging.Message;
import com.aelitis.azureus.core.peermanager.peerdb.PeerItem;
import com.aelitis.azureus.core.peermanager.peerdb.PeerItemFactory;
import com.aelitis.azureus.core.peermanager.piecepicker.util.BitFlags;
import java.util.*;
import org.gudy.azureus2.core3.disk.DiskManager;
import org.gudy.azureus2.core3.disk.DiskManagerReadRequest;
import org.gudy.azureus2.core3.peer.*;
import org.gudy.azureus2.core3.peer.impl.PEPeerControl;
import org.gudy.azureus2.core3.peer.impl.PEPeerTransport;
import org.gudy.azureus2.core3.util.*;
import org.gudy.azureus2.plugins.download.Download;
import org.gudy.azureus2.plugins.network.Connection;
import org.gudy.azureus2.plugins.peers.*;
import org.gudy.azureus2.plugins.torrent.Torrent;
import org.gudy.azureus2.pluginsimpl.local.messaging.MessageAdapter;

// Referenced classes of package org.gudy.azureus2.pluginsimpl.local.peers:
//			PeerForeignNetworkConnection, PeerManagerImpl, PeerStatsImpl

public class PeerForeignDelegate
	implements PEPeerTransport
{

	protected volatile int _lastPiece;
	private PeerManagerImpl manager;
	private Peer foreign;
	private NetworkConnectionBase network_connection;
	private long create_time;
	private long last_data_received_time;
	private long last_data_message_received_time;
	private int reserved_piece;
	private int consecutive_no_requests;
	private BitFlags bit_flags;
	private boolean priority_connection;
	private Map data;
	private HashMap peer_listeners;
	protected AEMonitor this_mon;

	protected PeerForeignDelegate(PeerManagerImpl _manager, Peer _foreign)
	{
		_lastPiece = -1;
		create_time = SystemTime.getCurrentTime();
		last_data_received_time = -1L;
		last_data_message_received_time = -1L;
		reserved_piece = -1;
		this_mon = new AEMonitor("PeerForeignDelegate");
		manager = _manager;
		foreign = _foreign;
		PEPeerManager pm = manager.getDelegate();
		network_connection = new PeerForeignNetworkConnection(foreign);
		network_connection.addRateLimiter(pm.getUploadLimitedRateGroup(), true);
		network_connection.addRateLimiter(pm.getDownloadLimitedRateGroup(), false);
	}

	public void start()
	{
		NetworkManager.getSingleton().startTransferProcessing(network_connection);
		NetworkManager.getSingleton().upgradeTransferProcessing(network_connection);
	}

	protected void stop()
	{
		NetworkManager.getSingleton().stopTransferProcessing(network_connection);
	}

	public void sendChoke()
	{
	}

	public void sendHave(int i)
	{
	}

	public void sendUnChoke()
	{
	}

	public boolean transferAvailable()
	{
		return foreign.isTransferAvailable();
	}

	public boolean isDownloadPossible()
	{
		return foreign.isDownloadPossible();
	}

	public void sendCancel(DiskManagerReadRequest request)
	{
		foreign.cancelRequest(request);
	}

	public DiskManagerReadRequest request(int pieceNumber, int pieceOffset, int pieceLength)
	{
		DiskManagerReadRequest request = manager.getDelegate().getDiskManager().createReadRequest(pieceNumber, pieceOffset, pieceLength);
		if (foreign.addRequest(request))
			return request;
		else
			return null;
	}

	public int getRequestIndex(DiskManagerReadRequest request)
	{
		return foreign.getRequests().indexOf(request);
	}

	protected void dataReceived()
	{
		last_data_received_time = SystemTime.getCurrentTime();
	}

	public void closeConnection(String reason)
	{
		foreign.close(reason, false, false);
		stop();
		break MISSING_BLOCK_LABEL_26;
		Exception exception;
		exception;
		stop();
		throw exception;
	}

	public List getExpiredRequests()
	{
		return foreign.getExpiredRequests();
	}

	public int getMaxNbRequests()
	{
		return foreign.getMaximumNumberOfRequests();
	}

	public int getNbRequests()
	{
		return foreign.getNumberOfRequests();
	}

	public int[] getPriorityOffsets()
	{
		return foreign.getPriorityOffsets();
	}

	public boolean requestAllocationStarts(int base_priorities[])
	{
		return foreign.requestAllocationStarts(base_priorities);
	}

	public void requestAllocationComplete()
	{
		foreign.requestAllocationComplete();
	}

	public PEPeerControl getControl()
	{
		return (PEPeerControl)manager.getDelegate();
	}

	public void updatePeerExchange()
	{
	}

	public PeerItem getPeerItemIdentity()
	{
		return PeerItemFactory.createPeerItem(foreign.getIp(), foreign.getTCPListenPort(), (byte)3, (byte)0, foreign.getUDPListenPort(), (byte)1, 0);
	}

	public int getConnectionState()
	{
		int peer_state = getPeerState();
		if (peer_state == 10)
			return 1;
		if (peer_state == 20)
			return 2;
		return peer_state != 30 ? 4 : 4;
	}

	public void doKeepAliveCheck()
	{
	}

	public boolean doTimeoutChecks()
	{
		return false;
	}

	public void doPerformanceTuningCheck()
	{
	}

	public long getTimeSinceConnectionEstablished()
	{
		long now = SystemTime.getCurrentTime();
		if (now > create_time)
			return now - create_time;
		else
			return 0L;
	}

	public long getTimeSinceLastDataMessageReceived()
	{
		if (last_data_message_received_time == -1L)
			return -1L;
		long now = SystemTime.getCurrentTime();
		if (last_data_message_received_time < now)
			last_data_message_received_time = now;
		return now - last_data_message_received_time;
	}

	public long getTimeSinceGoodDataReceived()
	{
		if (last_data_received_time == -1L)
			return -1L;
		long now = SystemTime.getCurrentTime();
		long time_since = now - last_data_received_time;
		if (time_since < 0L)
		{
			last_data_received_time = now;
			time_since = 0L;
		}
		return time_since;
	}

	public long getTimeSinceLastDataMessageSent()
	{
		return 0L;
	}

	public int getConsecutiveNoRequestCount()
	{
		return consecutive_no_requests;
	}

	public void setConsecutiveNoRequestCount(int num)
	{
		consecutive_no_requests = num;
	}

	public PEPeerManager getManager()
	{
		return manager.getDelegate();
	}

	public String getPeerSource()
	{
		return "Plugin";
	}

	public int getPeerState()
	{
		int peer_state = foreign.getState();
		return peer_state;
	}

	public byte[] getId()
	{
		return foreign.getId();
	}

	public String getIp()
	{
		return foreign.getIp();
	}

	public String getIPHostName()
	{
		return foreign.getIp();
	}

	public int getPort()
	{
		return foreign.getPort();
	}

	public int getTCPListenPort()
	{
		return foreign.getTCPListenPort();
	}

	public int getUDPListenPort()
	{
		return foreign.getUDPListenPort();
	}

	public int getUDPNonDataListenPort()
	{
		return foreign.getUDPNonDataListenPort();
	}

	public BitFlags getAvailable()
	{
		boolean flags[] = foreign.getAvailable();
		if (bit_flags == null || bit_flags.flags != flags)
			bit_flags = new BitFlags(flags);
		return bit_flags;
	}

	public boolean hasReceivedBitField()
	{
		return true;
	}

	public boolean isPieceAvailable(int pieceNumber)
	{
		return foreign.isPieceAvailable(pieceNumber);
	}

	public void setSnubbed(boolean b)
	{
		foreign.setSnubbed(b);
	}

	public boolean isChokingMe()
	{
		return foreign.isChoked();
	}

	public boolean isChokedByMe()
	{
		return foreign.isChoking();
	}

	public boolean isInteresting()
	{
		return foreign.isInteresting();
	}

	public boolean isInterested()
	{
		return foreign.isInterested();
	}

	public boolean isSeed()
	{
		return foreign.isSeed();
	}

	public boolean isRelativeSeed()
	{
		return false;
	}

	public boolean isSnubbed()
	{
		return foreign.isSnubbed();
	}

	public long getSnubbedTime()
	{
		return foreign.getSnubbedTime();
	}

	public boolean isLANLocal()
	{
		return AddressUtils.isLANLocalAddress(foreign.getIp()) == 1;
	}

	public boolean sendRequestHint(int piece_number, int offset, int length, int i)
	{
		return false;
	}

	public int[] getRequestHint()
	{
		return null;
	}

	public void clearRequestHint()
	{
	}

	public void sendBadPiece(int i)