diskmanagerchannelimpl.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:   DiskManagerChannelImpl.java

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

import com.aelitis.azureus.core.peermanager.piecepicker.PiecePicker;
import com.aelitis.azureus.core.peermanager.piecepicker.PieceRTAProvider;
import com.aelitis.azureus.core.util.CopyOnWriteList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.gudy.azureus2.core3.config.COConfigurationManager;
import org.gudy.azureus2.core3.config.ParameterListener;
import org.gudy.azureus2.core3.disk.DiskManagerFileInfo;
import org.gudy.azureus2.core3.disk.DiskManagerFileInfoListener;
import org.gudy.azureus2.core3.download.DownloadManager;
import org.gudy.azureus2.core3.download.DownloadManagerPeerListener;
import org.gudy.azureus2.core3.peer.PEPeer;
import org.gudy.azureus2.core3.peer.PEPeerManager;
import org.gudy.azureus2.core3.torrent.TOTorrent;
import org.gudy.azureus2.core3.torrent.TOTorrentFile;
import org.gudy.azureus2.core3.util.AESemaphore;
import org.gudy.azureus2.core3.util.Average;
import org.gudy.azureus2.core3.util.Debug;
import org.gudy.azureus2.core3.util.SystemTime;
import org.gudy.azureus2.plugins.disk.DiskManagerChannel;
import org.gudy.azureus2.plugins.disk.DiskManagerEvent;
import org.gudy.azureus2.plugins.disk.DiskManagerListener;
import org.gudy.azureus2.plugins.disk.DiskManagerRequest;
import org.gudy.azureus2.plugins.utils.PooledByteBuffer;
import org.gudy.azureus2.pluginsimpl.local.download.DownloadImpl;
import org.gudy.azureus2.pluginsimpl.local.utils.PooledByteBufferImpl;

// Referenced classes of package org.gudy.azureus2.pluginsimpl.local.disk:
//			DiskManagerFileInfoImpl

public class DiskManagerChannelImpl
	implements DiskManagerChannel, DiskManagerFileInfoListener, DownloadManagerPeerListener, PieceRTAProvider
{
	public static interface channelCreateListener
	{

		public abstract void channelCreated(DiskManagerChannel diskmanagerchannel);
	}

	protected static class dataEntry
	{

		private long offset;
		private long length;

		protected long getOffset()
		{
			return offset;
		}

		protected long getLength()
		{
			return length;
		}

		protected void setLength(long _length)
		{
			length = _length;
		}

		protected String getString()
		{
			return (new StringBuilder()).append("offset=").append(offset).append(",length=").append(length).toString();
		}

		protected dataEntry(long _offset, long _length)
		{
			offset = _offset;
			length = _length;
		}
	}

	protected class request
		implements DiskManagerRequest
	{
		protected class event
			implements DiskManagerEvent
		{

			private int event_type;
			private Throwable error;
			private PooledByteBuffer buffer;
			private long event_offset;
			private int event_length;
			final request this$1;

			public int getType()
			{
				return event_type;
			}

			public DiskManagerRequest getRequest()
			{
				return request.this;
			}

			public long getOffset()
			{
				return event_offset;
			}

			public int getLength()
			{
				return event_length;
			}

			public PooledByteBuffer getBuffer()
			{
				return buffer;
			}

			public Throwable getFailure()
			{
				return error;
			}

			protected event(Throwable _error)
			{
				this$1 = request.this;
				super();
				event_type = 2;
				error = _error;
			}

			protected event(long _offset)
			{
				this$1 = request.this;
				super();
				event_type = 3;
				event_offset = _offset;
			}

			protected event(PooledByteBuffer _buffer, long _offset, int _length)
			{
				this$1 = request.this;
				super();
				event_type = 1;
				buffer = _buffer;
				event_offset = _offset;
				event_length = _length;
			}
		}


		private int request_type;
		private long request_offset;
		private long request_length;
		private List listeners;
		private String user_agent;
		private int max_read_chunk;
		private volatile boolean cancelled;
		AESemaphore wait_sem;
		final DiskManagerChannelImpl this$0;

		public void setType(int _type)
		{
			request_type = _type;
		}

		public void setOffset(long _offset)
		{
			request_offset = _offset;
			start_position = request_offset;
		}

		public void setLength(long _length)
		{
			if (_length < 0L)
			{
				throw new RuntimeException("Illegal argument");
			} else
			{
				request_length = _length;
				return;
			}
		}

		public void setMaximumReadChunkSize(int size)
		{
			max_read_chunk = size;
		}

		public long getRemaining()
		{
			Set set = data_written;
			JVM INSTR monitorenter ;
			return request_length - (current_position - request_offset);
			Exception exception;
			exception;
			throw exception;
		}

		public void setUserAgent(String str)
		{
			user_agent = str;
		}

		protected String getUserAgent()
		{
			return user_agent;
		}

		public long getAvailableBytes()
		{
			if (plugin_file.getDownloaded() == plugin_file.getLength())
				return getRemaining();
			int download_state = download.getState();
			if (download_state != 4 && download_state != 5)
				return -1L;
			Set set = data_written;
			JVM INSTR monitorenter ;
			dataEntry last_entry;
			Iterator it = data_written.iterator();
			last_entry = null;
			do
			{
				if (!it.hasNext())
					break;
				dataEntry entry = (dataEntry)it.next();
				long entry_offset = entry.getOffset();
				long entry_length = entry.getLength();
				if (last_entry == null)
				{
					if (entry_offset > current_position)
						break;
					if (entry_offset <= current_position && current_position < entry_offset + entry_length)
						last_entry = entry;
					continue;
				}
				if (last_entry.getOffset() + last_entry.getLength() != entry.getOffset())
					break;
				last_entry = entry;
			} while (true);
			if (last_entry == null)
				return 0L;
			(last_entry.getOffset() + last_entry.getLength()) - current_position;
			set;
			JVM INSTR monitorexit ;
			return;
			Exception exception;
			exception;
			throw exception;
		}

		public void run()
		{
			long rem;
			long pos;
			rem = request_length;
			pos = request_offset;
_L1:
			do
			{
label0:
				{
					if (rem <= 0L || cancelled)
						break MISSING_BLOCK_LABEL_450;
					int len = 0;
					synchronized (data_written)
					{
						current_position = pos;
						Iterator it = data_written.iterator();
						do
						{
							if (!it.hasNext())
								break;
							dataEntry entry = (dataEntry)it.next();
							long entry_offset = entry.getOffset();
							if (entry_offset > pos)
								break;
							long entry_length = entry.getLength();
							long available = (entry_offset + entry_length) - pos;
							if (available <= 0L)
								continue;
							len = (int)available;
							break;
						} while (true);
					}
					if (len <= 0)
						break label0;
					if ((long)len > rem)
						len = (int)rem;
					if (len > max_read_chunk)
						len = max_read_chunk;
					org.gudy.azureus2.core3.util.DirectByteBuffer buffer = core_file.read(pos, len);
					inform(new event(new PooledByteBufferImpl(buffer), pos, len));
					pos += len;
					rem -= len;
					synchronized (data_written)
					{
						byte_rate.addValue(len);
						current_position = pos;
					}
				}
			} while (true);
			inform(new event(pos));
			synchronized (data_written)
			{
				waiters.add(wait_sem);
			}
			wait_sem.reserve();
			synchronized (data_written)
			{
				waiters.remove(wait_sem);
			}
			  goto _L1
			Exception exception4;
			exception4;
			synchronized (data_written)
			{
				waiters.remove(wait_sem);
			}
			throw exception4;
			Throwable e;
			e;
			inform(e);
		}

		public void cancel()
		{
			cancelled = true;
			inform(new Throwable("Request cancelled"));
			wait_sem.release();
		}

		protected void inform(Throwable e)
		{
			inform(new event(e));
		}