import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
@Override
public void update(Observable observable, Object data) {
    Client client = (Client) observable;
    Client.ClientState state = (Client.ClientState) data;
    SharedTorrent st = client.getTorrent();

    long now = System.nanoTime();
    long downloaded = st.getDownloaded();

    torrentDownloadStatus.setEstTimeNano(DownloadStatus.computeEstTime(startTime, now, downloaded, st.getLeft() + st.getDownloaded()));
    torrentDownloadStatus.setSpeedNano((downloaded - lastDownloaded) / (double) (now - lastTime));
    torrentDownloadStatus.updateValues(client);

    if(st.isFinished() || canceled || state.equals(Client.ClientState.ERROR) || state.equals(Client.ClientState.DONE)) {
        finishDwonload();
        return;
    }

    statusUpdater.notifyDownloadStatusUpdaters(torrentDownloadStatus);

    lastDownloaded = downloaded;
    lastTime = now;

}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
public void updateValues(Client client) {
    SharedTorrent sharedTorrent = client.getTorrent();
    this.setName(sharedTorrent.getName() + " (" + sharedTorrent.getFilenames().size() + " file(s))");
    this.setTotalSize(sharedTorrent.getSize());
    this.setDownloadedSize(sharedTorrent.getDownloaded());
    this.setProgress(sharedTorrent.getCompletion());
    this.setState(String.valueOf(client.getState()));
    this.setComment(sharedTorrent.getComment());
    this.setPieceCount(sharedTorrent.getPieceCount());
    this.setCompletion(sharedTorrent.getCompletion());
    this.setUploaded(sharedTorrent.getUploaded());
    this.setMaxDownloadRate(sharedTorrent.getMaxDownloadRate());
    this.setMaxUploadRate(sharedTorrent.getMaxUploadRate());
    List<PeerDataTO> peers = client.getPeers().stream().map(PeerDataTO::new).collect(Collectors.toList());
    this.setPeers(peers);
    this.setPeersCount(client.getPeers().size());
    this.setTrackerCount(sharedTorrent.getTrackerCount());
    this.setInfoHash(sharedTorrent.getHexInfoHash());
    this.setFilenames(sharedTorrent.getFilenames());
    if (sharedTorrent.isInitialized()) {
        this.setCompletedPieces(Util.compressToUri(sharedTorrent.getCompletedPieces()));
        this.setAvailablePieces(Util.compressToUri(sharedTorrent.getAvailablePieces()));
        this.setRequestedPieces(Util.compressToUri(sharedTorrent.getRequestedPieces()));
    }
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
private void init() throws UnknownHostException, NoSuchAlgorithmException, IOException{
	this.setTitle(torrent.getName());
	Client torrentClient = new Client(InetAddress.getLocalHost(), 
			SharedTorrent.fromFile(torrent,folder));
	torrentClient.addObserver(this);
	this.getContentPane().setLayout(new BoxLayout(this.getContentPane(), BoxLayout.PAGE_AXIS));
	this.getContentPane().add(state);
	this.getContentPane().add(peers);
	this.getContentPane().add(dl);
	this.getContentPane().add(completion);
	this.setLocationRelativeTo(null);
	this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
	this.setSize(400, 122);
	this.setResizable(false);
	this.setVisible(true);
	torrentClient.download();
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
public TfsTorrent addTorrent(Torrent torrent) throws IOException {
  String infoHash = torrent.getHexInfoHash();
  if (lookup.containsKey(infoHash)) return lookup.get(infoHash);

  File f = new File(rootPath + infoHash + "/");
  f.mkdirs();
  TfsTorrent tfs = null;
  try {
    tfs = new TfsTorrent(new Client(address, new SharedTorrent(torrent, f)), infoHash);
  } catch (NoSuchAlgorithmException e) {
    throw new RuntimeException("Required Crypto algorithms not installed.");
  }
  tfs.client.addObserver(new Observer() {
    @Override
    public void update(Observable arg0, Object arg1) {
      onClientUpdate((Client) arg0, (ClientState) arg1);
    }
  });
  lookup.put(infoHash, tfs);
  tfs.client.share();
  return tfs;
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
/**
 * 
 * @param torrent
 */
protected UDPTrackerClient(SharedTorrent torrent, Peer peer, URI tracker)
	throws UnknownHostException {
	super(torrent, peer, tracker);

	/**
	 * The UDP announce request protocol only supports IPv4
	 *
	 * @see http://bittorrent.org/beps/bep_0015.html#ipv6
	 */
	if (! (InetAddress.getByName(peer.getIp()) instanceof Inet4Address)) {
		throw new UnsupportedAddressTypeException();
	}

	this.address = new InetSocketAddress(
		tracker.getHost(),
		tracker.getPort());

	this.socket = null;
	this.random = new Random();
	this.connectionExpiration = null;
	this.stop = false;
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
private Client startSeeder() throws IOException, NoSuchAlgorithmException {
    Torrent torrent = Torrent.load(new File(TORRENT_FILE));
    File destination = new File(CONTENT_DIRECTORY);
    InetAddress addr = InetAddress.getLocalHost();
    Client client = new Client(addr, new SharedTorrent(torrent, destination));
    client.share();
    return client;
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
public void stopSeedingByPath(File file){
   final SharedTorrent torrentByName = myClient.getTorrentByFilePath(file);
   if (torrentByName != null) {
     LOG.info("Stopped seeding torrent by file: " + file.getAbsolutePath());
     myClient.removeTorrent(torrentByName);
   }
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
public File findSeedingTorrentFolder(@NotNull TorrentHash torrent){
  for (SharedTorrent st : myClient.getTorrents()) {
    if (st.getHexInfoHash().equals(torrent.getHexInfoHash())){
      return st.getParentFile();
    }
  }
  return null;
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
/**
 * Create a {@link TrackerClient} annoucing to the given tracker address.
 *
 * @param torrent The torrent the tracker client will be announcing for.
 * @param peer The peer the tracker client will announce on behalf of.
 * @param tracker The tracker address as a {@link URI}.
 * @throws UnknownHostException If the tracker address is invalid.
 * @throws UnknownServiceException If the tracker protocol is not supported.
 */
private TrackerClient createTrackerClient(SharedTorrent torrent, Peer peer,
	URI tracker) throws UnknownHostException, UnknownServiceException {
	String scheme = tracker.getScheme();

	if ("http".equals(scheme) || "https".equals(scheme)) {
		return new HTTPTrackerClient(torrent, peer, tracker);
	} else if ("udp".equals(scheme)) {
		return new UDPTrackerClient(torrent, peer, tracker);
	}

	throw new UnknownServiceException(
		"Unsupported announce scheme: " + scheme + "!");
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
/**
 * Initialize and start a new peer exchange.
 *
 * @param peer The remote peer to communicate with.
 * @param torrent The torrent we're exchanging on with the peer.
 * @param channel A channel on the connected socket to the peer.
 */
public PeerExchange(SharingPeer peer, SharedTorrent torrent,
		SocketChannel channel) throws SocketException {
	this.peer = peer;
	this.torrent = torrent;
	this.channel = channel;

	this.listeners = new HashSet<MessageListener>();
	this.sendQueue = new LinkedBlockingQueue<PeerMessage>();

	if (!this.peer.hasPeerId()) {
		throw new IllegalStateException("Peer does not have a " +
				"peer ID. Was the handshake made properly?");
	}

	this.in = new IncomingThread();
	this.in.setName("bt-peer(" +
		this.peer.getShortHexPeerId() + ")-recv");

	this.out = new OutgoingThread();
	this.out.setName("bt-peer(" +
		this.peer.getShortHexPeerId() + ")-send");
	this.out.setDaemon(true);

	// Automatically start the exchange activity loops
	this.stop = false;
	this.in.start();
	this.out.start();

	logger.debug("Started peer exchange with {} for {}.",
		this.peer, this.torrent);

	// If we have pieces, start by sending a BITFIELD message to the peer.
	BitSet pieces = this.torrent.getCompletedPieces();
	if (pieces.cardinality() > 0) {
		this.send(PeerMessage.BitfieldMessage.craft(pieces));
	}
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
/**
 * Create a new sharing peer on a given torrent.
 *
 * @param ip The peer's IP address.
 * @param port The peer's port.
 * @param peerId The byte-encoded peer ID.
 * @param torrent The torrent this peer exchanges with us on.
 */
public SharingPeer(String ip, int port, ByteBuffer peerId,
		SharedTorrent torrent) {
	super(ip, port, peerId);

	this.torrent = torrent;
	this.listeners = new HashSet<PeerActivityListener>();
	this.availablePieces = new BitSet(this.torrent.getPieceCount());

	this.requestsLock = new Object();
	this.exchangeLock = new Object();

	this.reset();
	this.requestedPiece = null;
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
@Override
public HaveMessage validate(SharedTorrent torrent)
	throws MessageValidationException {
	if (this.piece >= 0 && this.piece < torrent.getPieceCount()) {
		return this;
	}

	throw new MessageValidationException(this);
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
public static BitfieldMessage parse(ByteBuffer buffer,
		SharedTorrent torrent) throws MessageValidationException {
	BitSet bitfield = new BitSet(buffer.remaining()*8);
	for (int i=0; i < buffer.remaining()*8; i++) {
		if ((buffer.get(i/8) & (1 << (7 -(i % 8)))) > 0) {
			bitfield.set(i);
		}
	}

	return new BitfieldMessage(buffer, bitfield)
		.validate(torrent);
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
@NotNull
public Collection<SharedTorrent> getSharedTorrents() {
  return myTorrentsSeeder.getSharedTorrents();
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
public Collection<SharedTorrent> getSharedTorrents() {
  return myTorrentsSeeder.getSharedTorrents();
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
@NotNull
public Collection<SharedTorrent> getSharedTorrents(){
  return myClient.getSharedTorrents();
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
public boolean isSeedingByPath(File file){
  final SharedTorrent torrentByName = myClient.getTorrentByFilePath(file);
  return torrentByName != null;
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
public Collection<SharedTorrent> getSharedTorrents(){
  return myClient.getTorrents();
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
/**
 * Initialize the base announce class members for the announcer.
 *
 * @param torrent The torrent we're announcing about.
 * @param peer Our peer specification.
 */
public Announce(SharedTorrent torrent, Peer peer) {
	this.peer = peer;
	this.clients = new ArrayList<List<TrackerClient>>();
	this.allClients = new HashSet<TrackerClient>();

	/**
	 * Build the tiered structure of tracker clients mapping to the
	 * trackers of the torrent.
	 */
	for (List<URI> tier : torrent.getAnnounceList()) {
		ArrayList<TrackerClient> tierClients = new ArrayList<TrackerClient>();
		for (URI tracker : tier) {
			try {
				TrackerClient client = this.createTrackerClient(torrent,
					peer, tracker);

				tierClients.add(client);
				this.allClients.add(client);
			} catch (Exception e) {
				logger.warn("Will not announce on {}: {}!",
					tracker,
					e.getMessage() != null
						? e.getMessage()
						: e.getClass().getSimpleName());
			}
		}

		// Shuffle the list of tracker clients once on creation.
		Collections.shuffle(tierClients);

		// Tier is guaranteed to be non-empty by
		// Torrent#parseAnnounceInformation(), so we can add it safely.
		clients.add(tierClients);
	}

	this.thread = null;
	this.currentTier = 0;
	this.currentClient = 0;

	logger.info("Initialized announce sub-system with {} trackers on {}.",
		new Object[] { torrent.getTrackerCount(), torrent });
}
 

import com.turn.ttorrent.client.SharedTorrent; //导入依赖的package包/类
public TrackerClient(SharedTorrent torrent, Peer peer, URI tracker) {
	this.listeners = new HashSet<AnnounceResponseListener>();
	this.torrent = torrent;
	this.peer = peer;
	this.tracker = tracker;
}