diskmanagerimpl.java

java 文件下载器。可自定义

				{
					allocated_files[i].getCacheFile().close();
				}
				catch (Throwable e) { }
			}

		}
		return e;
		numNewFiles++;
		i++;
		  goto _L2
		files = allocated_files;
		fileset = new DiskManagerFileInfoSetImpl(files, this);
		loadFilePriorities();
		download_manager.setDataAlreadyAllocated(true);
		i = numNewFiles;
		allocation_scheduler.unregister(this);
		if (files == null)
		{
			for (int i = 0; i < allocated_files.length; i++)
			{
				if (allocated_files[i] == null)
					continue;
				try
				{
					allocated_files[i].getCacheFile().close();
				}
				catch (Throwable e) { }
			}

		}
		return i;
		Exception exception1;
		exception1;
		allocation_scheduler.unregister(this);
		if (files == null)
		{
			for (int i = 0; i < allocated_files.length; i++)
			{
				if (allocated_files[i] == null)
					continue;
				try
				{
					allocated_files[i].getCacheFile().close();
				}
				catch (Throwable e) { }
			}

		}
		throw exception1;
	}

	public DiskAccessController getDiskAccessController()
	{
		return disk_access_controller;
	}

	public void enqueueReadRequest(DiskManagerReadRequest request, DiskManagerReadRequestListener listener)
	{
		reader.readBlock(request, listener);
	}

	public boolean hasOutstandingReadRequestForPiece(int piece_number)
	{
		return reader.hasOutstandingReadRequestForPiece(piece_number);
	}

	public int getNbPieces()
	{
		return nbPieces;
	}

	public int getPercentDone()
	{
		return percentDone;
	}

	public void setPercentDone(int num)
	{
		percentDone = num;
	}

	public long getRemaining()
	{
		return remaining;
	}

	public long getRemainingExcludingDND()
	{
		DiskManagerFileInfoImpl current_files[];
		if (!skipped_file_set_changed)
			break MISSING_BLOCK_LABEL_111;
		current_files = files;
		if (current_files == null)
			break MISSING_BLOCK_LABEL_111;
		skipped_file_set_changed = false;
		file_piece_mon.enter();
		skipped_file_set_size = 0L;
		skipped_but_downloaded = 0L;
		for (int i = 0; i < current_files.length; i++)
		{
			DiskManagerFileInfoImpl file = current_files[i];
			if (file.isSkipped())
			{
				skipped_file_set_size += file.getLength();
				skipped_but_downloaded += file.getDownloaded();
			}
		}

		file_piece_mon.exit();
		break MISSING_BLOCK_LABEL_111;
		Exception exception;
		exception;
		file_piece_mon.exit();
		throw exception;
		long rem = remaining - (skipped_file_set_size - skipped_but_downloaded);
		if (rem < 0L)
			rem = 0L;
		return rem;
	}

	public long getAllocated()
	{
		return allocated;
	}

	public void setAllocated(long num)
	{
		allocated = num;
	}

	public void setPieceDone(DiskManagerPieceImpl dmPiece, boolean done)
	{
		int piece_number;
		int piece_length;
		piece_number = dmPiece.getPieceNumber();
		piece_length = dmPiece.getLength();
		file_piece_mon.enter();
		if (dmPiece.isDone() != done)
		{
			dmPiece.setDoneSupport(done);
			if (done)
				remaining -= piece_length;
			else
				remaining += piece_length;
			DMPieceList piece_list = getPieceList(piece_number);
			for (int i = 0; i < piece_list.size();)
			{
				DMPieceMapEntry piece_map_entry = piece_list.get(i);
				DiskManagerFileInfoImpl this_file = piece_map_entry.getFile();
				long file_length = this_file.getLength();
				long file_done = this_file.getDownloaded();
				long file_done_before = file_done;
				if (done)
					file_done += piece_map_entry.getLength();
				else
					file_done -= piece_map_entry.getLength();
				if (file_done < 0L)
				{
					Debug.out("piece map entry length negative");
					file_done = 0L;
				} else
				if (file_done > file_length)
				{
					Debug.out("piece map entry length too large");
					file_done = file_length;
				}
				if (this_file.isSkipped())
					skipped_but_downloaded += file_done - file_done_before;
				this_file.setDownloaded(file_done);
				if (file_done != file_length || this_file.getAccessMode() != 2)
					continue;
				try
				{
					this_file.setAccessMode(1);
					continue;
				}
				catch (Exception e)
				{
					setFailed((new StringBuilder()).append("Disk access error - ").append(Debug.getNestedExceptionMessage(e)).toString());
					Debug.printStackTrace(e);
					i++;
				}
			}

			if (getState() == 4)
				listeners.dispatch(3, dmPiece);
		}
		file_piece_mon.exit();
		break MISSING_BLOCK_LABEL_325;
		Exception exception;
		exception;
		file_piece_mon.exit();
		throw exception;
	}

	public void accessModeChanged(DiskManagerFileInfoImpl file, int old_mode, int new_mode)
	{
		listeners.dispatch(4, ((Object) (new Object[] {
			file, new Integer(old_mode), new Integer(new_mode)
		})));
	}

	public DiskManagerPiece[] getPieces()
	{
		return pieces;
	}

	public DiskManagerPiece getPiece(int PieceNumber)
	{
		return pieces[PieceNumber];
	}

	public int getPieceLength()
	{
		return pieceLength;
	}

	public int getPieceLength(int piece_number)
	{
		if (piece_number == nbPieces - 1)
			return lastPieceLength;
		else
			return pieceLength;
	}

	public long getTotalLength()
	{
		return totalLength;
	}

	public int getLastPieceLength()
	{
		return lastPieceLength;
	}

	public int getState()
	{
		return state_set_via_method;
	}

	protected void setState(int _state)
	{
		if (state_set_via_method == 10)
		{
			if (_state != 10)
				Debug.out((new StringBuilder()).append("DiskManager: attempt to move from faulty state to ").append(_state).toString());
			return;
		}
		if (state_set_via_method != _state)
		{
			int params[] = {
				state_set_via_method, _state
			};
			state_set_via_method = _state;
			listeners.dispatch(1, params);
		}
	}

	public DiskManagerFileInfo[] getFiles()
	{
		return files;
	}

	public DiskManagerFileInfoSet getFileSet()
	{
		return fileset;
	}

	public String getErrorMessage()
	{
		return errorMessage;
	}

	public void setFailed(String reason)
	{
		(new AEThread(reason) {

			final String val$reason;
			final DiskManagerImpl this$0;

			public void runSupport()
			{
				errorMessage = reason;
				Logger.log(new LogAlert(DiskManagerImpl.this, false, 3, errorMessage));
				setState(10);
				stop(false);
			}

			
			{
				this$0 = DiskManagerImpl.this;
				reason = s;
				super(x0);
			}
		}).start();
	}

	public void setFailed(DiskManagerFileInfo file, String reason)
	{
		(new AEThread(file) {

			final String val$reason;
			final DiskManagerFileInfo val$file;
			final DiskManagerImpl this$0;

			public void runSupport()
			{
				errorMessage = reason;
				Logger.log(new LogAlert(DiskManagerImpl.this, false, 3, errorMessage));
				setState(10);
				stop(false);
				RDResumeHandler.recheckFile(download_manager, file);
			}

			
			{
				this$0 = DiskManagerImpl.this;
				reason = s;
				file = diskmanagerfileinfo;
				super(x0);
			}
		}).start();
	}

	public int getCacheMode()
	{
		return 1;
	}

	public DMPieceList getPieceList(int piece_number)
	{
		DMPieceMap map = piece_map_use_accessor;
		if (map == null)
			piece_map_use_accessor = map = piece_mapper.getPieceMap();
		piece_map_use_accessor_time = SystemTime.getCurrentTime();
		return map.getPieceList(piece_number);
	}

	public void checkFreePieceList(boolean force_discard)
	{
		if (piece_map_use_accessor == null)
			return;
		long now = SystemTime.getCurrentTime();
		if (!force_discard)
		{
			if (now < piece_map_use_accessor_time)
			{
				piece_map_use_accessor_time = now;
				return;
			}
			if (now - piece_map_use_accessor_time < 0x1d4c0L)
				return;
		}
		piece_map_use_accessor = null;
	}

	public byte[] getPieceHash(int piece_number)
		throws TOTorrentException
	{
		return torrent.getPieces()[piece_number];
	}

	public DiskManagerReadRequest createReadRequest(int pieceNumber, int offset, int length)
	{
		return reader.createReadRequest(pieceNumber, offset, length);
	}

	public DiskManagerCheckRequest createCheckRequest(int pieceNumber, Object user_data)
	{
		return checker.createCheckRequest(pieceNumber, user_data);
	}

	public boolean hasOutstandingCheckRequestForPiece(int piece_number)
	{
		return checker.hasOutstandingCheckRequestForPiece(piece_number);
	}

	public void enqueueCompleteRecheckRequest(DiskManagerCheckRequest request, DiskManagerCheckRequestListener listener)
	{
		checker.enqueueCompleteRecheckRequest(request, listener);
	}

	public void enqueueCheckRequest(DiskManagerCheckRequest request, DiskManagerCheckRequestListener listener)
	{
		checker.enqueueCheckRequest(request, listener);
	}

	public int getCompleteRecheckStatus()
	{
		return checker.getCompleteRecheckStatus();
	}

	public void setPieceCheckingEnabled(boolean enabled)
	{
		checking_enabled = enabled;
		checker.setCheckingEnabled(enabled);
	}

	public DirectByteBuffer readBlock(int pieceNumber, int offset, int length)
	{
		return reader.readBlock(pieceNumber, offset, length);
	}

	public DiskManagerWriteRequest createWriteRequest(int pieceNumber, int offset, DirectByteBuffer data, Object user_data)
	{
		return writer.createWriteRequest(pieceNumber, offset, data, user_data);
	}

	public void enqueueWriteRequest(DiskManagerWriteRequest request, DiskManagerWriteRequestListener listener)
	{
		writer.writeBlock(request, listener);
	}

	public boolean hasOutstandingWriteRequestForPiece(int piece_number)
	{
		return writer.hasOutstandingWriteRequestForPiece(piece_number);
	}

	public boolean checkBlockConsistencyForWrite(String originator, int pieceNumber, int offset, DirectByteBuffer data)
	{
		if (pieceNumber < 0)
		{
			if (Logger.isEnabled())
				Logger.log(new LogEvent(this, LOGID, 3, (new StringBuilder()).append("Write invalid: ").append(originator).append(" pieceNumber=").append(pieceNumber).append(" < 0").toString()));
			return false;