diskmanagerfileinfoimpl.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:   DiskManagerFileInfoImpl.java

package org.gudy.azureus2.core3.disk.impl;

import com.aelitis.azureus.core.diskmanager.cache.*;
import com.aelitis.azureus.core.util.CopyOnWriteList;
import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import org.gudy.azureus2.core3.disk.*;
import org.gudy.azureus2.core3.download.DownloadManager;
import org.gudy.azureus2.core3.download.DownloadManagerState;
import org.gudy.azureus2.core3.torrent.TOTorrent;
import org.gudy.azureus2.core3.torrent.TOTorrentFile;
import org.gudy.azureus2.core3.util.*;

// Referenced classes of package org.gudy.azureus2.core3.disk.impl:
//			DiskManagerHelper, DiskManagerUtil

public class DiskManagerFileInfoImpl
	implements DiskManagerFileInfo, CacheFileOwner
{

	private File file;
	private int file_index;
	private CacheFile cache_file;
	private String extension;
	private long downloaded;
	private DiskManagerHelper diskManager;
	private TOTorrentFile torrent_file;
	boolean priority;
	boolean skipped;
	private CopyOnWriteList listeners;

	public DiskManagerFileInfoImpl(DiskManagerHelper _disk_manager, File _file, int _file_index, TOTorrentFile _torrent_file, boolean _linear_storage)
		throws CacheFileManagerException
	{
		priority = false;
		skipped = false;
		diskManager = _disk_manager;
		torrent_file = _torrent_file;
		file = _file;
		file_index = _file_index;
		cache_file = CacheFileManagerFactory.getSingleton().createFile(this, _file, _linear_storage ? 1 : 2);
		if (!_linear_storage)
			skipped = true;
	}

	public String getCacheFileOwnerName()
	{
		return diskManager.getInternalName();
	}

	public TOTorrentFile getCacheFileTorrentFile()
	{
		return torrent_file;
	}

	public File getCacheFileControlFileDir()
	{
		return diskManager.getDownloadState().getStateFile();
	}

	public int getCacheMode()
	{
		return diskManager.getCacheMode();
	}

	public void flushCache()
		throws Exception
	{
		cache_file.flushCache();
	}

	protected void moveFile(File newFile, boolean link_only)
		throws CacheFileManagerException
	{
		if (!link_only)
			cache_file.moveFile(newFile);
		file = newFile;
	}

	public CacheFile getCacheFile()
	{
		return cache_file;
	}

	public void setAccessMode(int mode)
		throws CacheFileManagerException
	{
		int old_mode = cache_file.getAccessMode();
		cache_file.setAccessMode(mode != 1 ? 2 : 1);
		if (old_mode != mode)
			diskManager.accessModeChanged(this, old_mode, mode);
	}

	public int getAccessMode()
	{
		int mode = cache_file.getAccessMode();
		return mode != 1 ? 2 : 1;
	}

	public long getDownloaded()
	{
		return downloaded;
	}

	public String getExtension()
	{
		return extension;
	}

	public File getFile(boolean follow_link)
	{
		if (follow_link)
		{
			File res = getLink();
			if (res != null)
				return res;
		}
		return file;
	}

	public TOTorrentFile getTorrentFile()
	{
		return torrent_file;
	}

	public boolean setLink(File link_destination)
	{
		Debug.out("setLink: download must be stopped");
		return false;
	}

	public boolean setLinkAtomic(File link_destination)
	{
		Debug.out("setLink: download must be stopped");
		return false;
	}

	public File getLink()
	{
		return diskManager.getDownloadState().getFileLink(getFile(false));
	}

	public boolean setStorageType(int type)
	{
		DiskManagerFileInfoSet set = diskManager.getFileSet();
		boolean toSet[] = new boolean[set.nbFiles()];
		toSet[file_index] = true;
		return set.setStorageTypes(toSet, type)[file_index];
	}

	public int getStorageType()
	{
		return diskManager.getStorageType(file_index).equals("L") ? 1 : 2;
	}

	protected boolean isLinked()
	{
		return getLink() != null;
	}

	public int getFirstPieceNumber()
	{
		return torrent_file.getFirstPieceNumber();
	}

	public int getLastPieceNumber()
	{
		return torrent_file.getLastPieceNumber();
	}

	public long getLength()
	{
		return torrent_file.getLength();
	}

	public int getIndex()
	{
		return file_index;
	}

	public int getNbPieces()
	{
		return torrent_file.getNumberOfPieces();
	}

	public void setDownloaded(long l)
	{
		downloaded = l;
	}

	public void setExtension(String string)
	{
		extension = StringInterner.intern(string);
	}

	public boolean isPriority()
	{
		return priority;
	}

	public void setPriority(boolean b)
	{
		priority = b;
		diskManager.priorityChanged(this);
	}

	public boolean isSkipped()
	{
		return skipped;
	}

	public void setSkipped(boolean _skipped)
	{
		if (!_skipped && getStorageType() == 2 && !setStorageType(1))
			return;
		skipped = _skipped;
		diskManager.skippedFileSetChanged(this);
		if (!_skipped)
		{
			boolean toCheck[] = new boolean[diskManager.getFileSet().nbFiles()];
			toCheck[file_index] = true;
			DiskManagerUtil.doFileExistenceChecks(diskManager.getFileSet(), toCheck, diskManager.getDownloadState().getDownloadManager(), true);
		}
	}

	public DiskManager getDiskManager()
	{
		return diskManager;
	}

	public DownloadManager getDownloadManager()
	{
		DownloadManagerState state = diskManager.getDownloadState();
		if (state == null)
			return null;
		else
			return state.getDownloadManager();
	}

	public void dataWritten(long offset, long size)
	{
		if (listeners != null)
		{
			for (Iterator it = listeners.iterator(); it.hasNext();)
				try
				{
					((DiskManagerFileInfoListener)it.next()).dataWritten(offset, size);
				}
				catch (Throwable e)
				{
					Debug.printStackTrace(e);
				}

		}
	}

	public void dataChecked(long offset, long size)
	{
		if (listeners != null)
		{
			for (Iterator it = listeners.iterator(); it.hasNext();)
				try
				{
					((DiskManagerFileInfoListener)it.next()).dataChecked(offset, size);
				}
				catch (Throwable e)
				{
					Debug.printStackTrace(e);
				}

		}
	}

	public DirectByteBuffer read(long offset, int length)
		throws IOException
	{
		DirectByteBuffer buffer = DirectByteBufferPool.getBuffer((byte)6, length);
		try
		{
			cache_file.read(buffer, offset, (short)1);
		}
		catch (Throwable e)
		{
			buffer.returnToPool();
			Debug.printStackTrace(e);
			throw new IOException(e.getMessage());
		}
		return buffer;
	}

	public void close()
	{
	}

	public void addListener(final DiskManagerFileInfoListener listener)
	{
label0:
		{
			if (listeners == null)
				listeners = new CopyOnWriteList();
			synchronized (listeners)
			{
				if (!listeners.getList().contains(listener))
					break label0;
			}
			return;
		}
		copyonwritelist;
		JVM INSTR monitorexit ;
		  goto _L1
		exception;
		throw exception;
_L1:
		listeners.add(listener);
		(new Runnable() {

			private long file_start;
			private long file_end;
			private long current_write_start;
			private long current_write_end;
			private long current_check_start;
			private long current_check_end;
			final DiskManagerFileInfoListener val$listener;
			final DiskManagerFileInfoImpl this$0;

			public void run()
			{
				TOTorrentFile tfs[] = torrent_file.getTorrent().getFiles();
				long torrent_offset = 0L;
				for (int i = 0; i < file_index; i++)
					torrent_offset += tfs[i].getLength();

				file_start = torrent_offset;
				file_end = file_start + torrent_file.getLength();
				DiskManagerPiece pieces[] = diskManager.getPieces();
				int first_piece = getFirstPieceNumber();
				int last_piece = getLastPieceNumber();
				long piece_size = torrent_file.getTorrent().getPieceLength();
label0:
				for (int i = first_piece; i <= last_piece; i++)
				{
					long piece_offset = piece_size * (long)i;
					DiskManagerPiece piece = pieces[i];
					if (piece.isDone())
					{
						long bit_start = piece_offset;
						long bit_end = bit_start + (long)piece.getLength();
						bitWritten(bit_start, bit_end, true);
						continue;
					}
					int block_offset = 0;
					int j = 0;
					do
					{
						if (j >= piece.getNbBlocks())
							continue label0;
						int block_size = piece.getBlockSize(j);
						if (piece.isWritten(j))
						{
							long bit_start = piece_offset + (long)block_offset;
							long bit_end = bit_start + (long)block_size;
							bitWritten(bit_start, bit_end, false);
						}
						block_offset += block_size;
						j++;
					} while (true);
				}

				bitWritten(-1L, -1L, false);
			}

			protected void bitWritten(long bit_start, long bit_end, boolean checked)
			{
				if (current_write_start == -1L)
				{
					current_write_start = bit_start;
					current_write_end = bit_end;
				} else
				if (current_write_end == bit_start)
				{
					current_write_end = bit_end;
				} else
				{
					if (current_write_start < file_start)
						current_write_start = file_start;
					if (current_write_end > file_end)
						current_write_end = file_end;
					if (current_write_start < current_write_end)
						try
						{
							listener.dataWritten(current_write_start - file_start, current_write_end - current_write_start);
						}
						catch (Throwable e)
						{
							Debug.printStackTrace(e);
						}
					current_write_start = bit_start;
					current_write_end = bit_end;
				}
				if (checked && current_check_start == -1L)
				{
					current_check_start = bit_start;
					current_check_end = bit_end;
				} else
				if (checked && current_check_end == bit_start)
				{
					current_check_end = bit_end;
				} else
				{
					if (current_check_start < file_start)
						current_check_start = file_start;
					if (current_check_end > file_end)
						current_check_end = file_end;
					if (current_check_start < current_check_end)
						try
						{
							listener.dataChecked(current_check_start - file_start, current_check_end - current_check_start);
						}
						catch (Throwable e)
						{
							Debug.printStackTrace(e);
						}
					if (checked)
					{
						current_check_start = bit_start;
						current_check_end = bit_end;
					} else
					{
						current_check_start = -1L;
						current_check_end = -1L;
					}
				}
			}

			
			{
				this$0 = DiskManagerFileInfoImpl.this;
				listener = diskmanagerfileinfolistener;
				super();
				current_write_start = -1L;
				current_write_end = -1L;
				current_check_start = -1L;
				current_check_end = -1L;
			}
		}).run();
		return;
	}

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



}