diskmanagerchannelimpl.java

java 文件下载器。可自定义

		protected void inform(event ev)
		{
			for (int i = 0; i < listeners.size(); i++)
				try
				{
					((DiskManagerListener)listeners.get(i)).eventOccurred(ev);
				}
				catch (Throwable e)
				{
					Debug.printStackTrace(e);
				}

		}

		public void addListener(DiskManagerListener listener)
		{
			listeners.add(listener);
		}

		public void removeListener(DiskManagerListener listener)
		{
			listeners.remove(listener);
		}

		protected request()
		{
			this$0 = DiskManagerChannelImpl.this;
			super();
			listeners = new ArrayList();
			max_read_chunk = 0x10000;
			wait_sem = new AESemaphore("DiskManagerChannelImpl:wait");
			start_time = SystemTime.getCurrentTime();
		}
	}


	private static int BUFFER_MILLIS;
	private static int MIN_PIECES_TO_BUFFER;
	private static final boolean TRACE = false;
	private static final int COMPACT_DELAY = 32;
	private static final int MAX_READ_CHUNK_DEFAULT = 0x10000;
	private static final Comparator comparator = new Comparator() {

		public int compare(Object _o1, Object _o2)
		{
			dataEntry o1 = (dataEntry)_o1;
			dataEntry o2 = (dataEntry)_o2;
			long offset1 = o1.getOffset();
			long length1 = o1.getLength();
			long offset2 = o2.getOffset();
			long length2 = o2.getLength();
			long res;
			if (offset1 == offset2)
				res = length1 - length2;
			else
				res = offset1 - offset2;
			if (res == 0L)
				return 0;
			return res >= 0L ? 1 : -1;
		}

	};
	private static final String channel_key = "DiskManagerChannel";
	private static int channel_id_next;
	private static CopyOnWriteList listeners = new CopyOnWriteList();
	private DownloadImpl download;
	private DiskManagerFileInfoImpl plugin_file;
	private DiskManagerFileInfo core_file;
	private Set data_written;
	private int compact_delay;
	private List waiters;
	private long file_offset_in_torrent;
	private long piece_size;
	private Average byte_rate;
	private long start_position;
	private long start_time;
	private long current_position;
	private request current_request;
	private long buffer_millis;
	private PEPeerManager peer_manager;
	private long rtas[];
	private int channel_id;

	public static void addListener(channelCreateListener l)
	{
		listeners.add(l);
	}

	public static void removeListener(channelCreateListener l)
	{
		listeners.remove(l);
	}

	protected static void reportCreated(DiskManagerChannel channel)
	{
		for (Iterator it = listeners.iterator(); it.hasNext();)
			try
			{
				((channelCreateListener)it.next()).channelCreated(channel);
			}
			catch (Throwable e)
			{
				Debug.printStackTrace(e);
			}

	}

	protected DiskManagerChannelImpl(DownloadImpl _download, DiskManagerFileInfoImpl _plugin_file)
	{
		data_written = new TreeSet(comparator);
		compact_delay = 32;
		waiters = new ArrayList();
		byte_rate = Average.getInstance(1000, 20);
		download = _download;
		plugin_file = _plugin_file;
		core_file = plugin_file.getCore();
		synchronized (org/gudy/azureus2/pluginsimpl/local/disk/DiskManagerChannelImpl)
		{
			channel_id = channel_id_next++;
		}
		TOTorrentFile tf = core_file.getTorrentFile();
		TOTorrent torrent = tf.getTorrent();
		TOTorrentFile tfs[] = torrent.getFiles();
		rtas = new long[torrent.getNumberOfPieces()];
		core_file.getDownloadManager().addPeerListener(this);
		for (int i = 0; i < core_file.getIndex(); i++)
			file_offset_in_torrent += tfs[i].getLength();

		piece_size = tf.getTorrent().getPieceLength();
		core_file.addListener(this);
		reportCreated(this);
	}

	public org.gudy.azureus2.plugins.disk.DiskManagerFileInfo getFile()
	{
		return plugin_file;
	}

	public DiskManagerRequest createRequest()
	{
		if (core_file.getDownloaded() != core_file.getLength())
		{
			if (core_file.isSkipped())
				core_file.setSkipped(false);
			boolean force_start = download.isForceStart();
			if (!force_start)
			{
				synchronized (download)
				{
					Map dl_state = (Map)download.getDownload().getData("DiskManagerChannel");
					if (dl_state == null)
					{
						dl_state = new HashMap();
						download.getDownload().setData("DiskManagerChannel", dl_state);
					}
					dl_state.put((new StringBuilder()).append("").append(channel_id).toString(), "");
				}
				download.setForceStart(true);
			}
		}
		current_request = new request();
		return current_request;
	}

	public void dataWritten(long offset, long length)
	{
		dataEntry entry = new dataEntry(offset, length);
		synchronized (data_written)
		{
			data_written.add(entry);
			compact_delay--;
			if (compact_delay == 0)
			{
				compact_delay = 32;
				Iterator it = data_written.iterator();
				dataEntry prev_e = null;
				while (it.hasNext()) 
				{
					dataEntry this_e = (dataEntry)it.next();
					if (prev_e == null)
					{
						prev_e = this_e;
					} else
					{
						long prev_offset = prev_e.getOffset();
						long prev_length = prev_e.getLength();
						long this_offset = this_e.getOffset();
						long this_length = this_e.getLength();
						if (this_offset <= prev_offset + prev_length)
						{
							it.remove();
							prev_e.setLength(Math.max(prev_offset + prev_length, this_offset + this_length) - prev_offset);
						} else
						{
							prev_e = this_e;
						}
					}
				}
			}
			for (int i = 0; i < waiters.size(); i++)
				((AESemaphore)waiters.get(i)).release();

		}
	}

	public void dataChecked(long l, long l1)
	{
	}

	public void peerManagerWillBeAdded(PEPeerManager pepeermanager)
	{
	}

	public void peerManagerAdded(PEPeerManager manager)
	{
		peer_manager = manager;
		manager.getPiecePicker().addRTAProvider(this);
	}

	public void peerManagerRemoved(PEPeerManager manager)
	{
		peer_manager = null;
		manager.getPiecePicker().removeRTAProvider(this);
	}

	public void peerAdded(PEPeer pepeer)
	{
	}

	public void peerRemoved(PEPeer pepeer)
	{
	}

	public long[] updateRTAs(PiecePicker picker)
	{
		long overall_pos = current_position + file_offset_in_torrent;
		int first_piece = (int)(overall_pos / piece_size);
		long rate = byte_rate.getAverage();
		long buffer_bytes = ((long)BUFFER_MILLIS * rate) / 1000L;
		int pieces_to_buffer = (int)(buffer_bytes / piece_size);
		if (pieces_to_buffer < 1)
			pieces_to_buffer = 1;
		int millis_per_piece = BUFFER_MILLIS / pieces_to_buffer;
		if (pieces_to_buffer < MIN_PIECES_TO_BUFFER)
			pieces_to_buffer = MIN_PIECES_TO_BUFFER;
		Arrays.fill(rtas, 0L);
		long now = SystemTime.getCurrentTime();
		now += buffer_millis;
		for (int i = first_piece; i < first_piece + pieces_to_buffer && i < rtas.length; i++)
			rtas[i] = now + (long)((i - first_piece) * millis_per_piece);

		return rtas;
	}

	public long getStartTime()
	{
		return start_time;
	}

	public long getStartPosition()
	{
		return start_position;
	}

	public long getCurrentPosition()
	{
		return current_position;
	}

	public long getBlockingPosition()
	{
		request r = current_request;
		if (r == null)
			return current_position;
		else
			return current_position + r.getAvailableBytes();
	}

	public void setBufferMillis(long millis)
	{
		buffer_millis = millis;
	}

	public String getUserAgent()
	{
		request r = current_request;
		if (r == null)
			return null;
		else
			return r.getUserAgent();
	}

	public void destroy()
	{
		core_file.removeListener(this);
		core_file.getDownloadManager().removePeerListener(this);
		if (peer_manager != null)
			peer_manager.getPiecePicker().removeRTAProvider(this);
		boolean stop_force_start = false;
		synchronized (download)
		{
			Map dl_state = (Map)download.getDownload().getData("DiskManagerChannel");
			if (dl_state != null)
			{
				dl_state.remove((new StringBuilder()).append("").append(channel_id).toString());
				if (dl_state.size() == 0)
					stop_force_start = true;
			}
		}
		if (stop_force_start)
			download.setForceStart(false);
	}

	static 
	{
		COConfigurationManager.addAndFireParameterListeners(new String[] {
			"filechannel.rt.buffer.millis", "filechannel.rt.buffer.pieces"
		}, new ParameterListener() {

			public void parameterChanged(String parameterName)
			{
				DiskManagerChannelImpl.BUFFER_MILLIS = COConfigurationManager.getIntParameter("filechannel.rt.buffer.millis");
				DiskManagerChannelImpl.MIN_PIECES_TO_BUFFER = COConfigurationManager.getIntParameter("filechannel.rt.buffer.pieces");
			}

		});
	}












}