rdresumehandler.java

java 文件下载器。可自定义

		check_in_progress = false;
		break MISSING_BLOCK_LABEL_1537;
		Exception exception;
		exception;
		check_in_progress = false;
		throw exception;
		if (!stopped && !resume_data_complete)
			try
			{
				saveResumeData(true);
			}
			catch (Exception e)
			{
				Debug.out("Failed to dump initial resume data to disk");
				Debug.printStackTrace(e);
			}
		recheck_inst.unregister();
		break MISSING_BLOCK_LABEL_1599;
		Throwable e;
		e;
		Debug.printStackTrace(e);
		recheck_inst.unregister();
		break MISSING_BLOCK_LABEL_1599;
		Exception exception1;
		exception1;
		recheck_inst.unregister();
		throw exception1;
	}

	public void saveResumeData(boolean interim_save)
		throws Exception
	{
		if (check_in_progress && interim_save)
			return;
		DiskManagerFileInfo files[] = disk_manager.getFiles();
		if (!use_fast_resume)
		{
			for (int i = 0; i < files.length; i++)
				files[i].flushCache();

			return;
		}
		boolean was_complete = isTorrentResumeDataComplete(disk_manager.getDownloadManager().getDownloadState());
		DiskManagerPiece pieces[] = disk_manager.getPieces();
		byte resume_pieces[] = new byte[pieces.length];
		for (int i = 0; i < resume_pieces.length; i++)
		{
			DiskManagerPiece piece = pieces[i];
			if (stopped_for_close && check_interrupted && check_is_full_check && i >= check_position)
			{
				resume_pieces[i] = 2;
				continue;
			}
			if (piece.isDone())
			{
				resume_pieces[i] = 1;
				continue;
			}
			if (piece.getNbWritten() > 0)
				resume_pieces[i] = 3;
			else
				resume_pieces[i] = 0;
		}

		Map resume_data = new HashMap();
		resume_data.put("resume data", resume_pieces);
		Map partialPieces = new HashMap();
		for (int i = 0; i < pieces.length; i++)
		{
			DiskManagerPiece piece = pieces[i];
			boolean written[] = piece.getWritten();
			if (piece.isDone() || piece.getNbWritten() <= 0 || written == null)
				continue;
			boolean all_written = true;
			int j = 0;
			do
			{
				if (j >= written.length)
					break;
				if (!written[j])
				{
					all_written = false;
					break;
				}
				j++;
			} while (true);
			if (all_written)
			{
				resume_pieces[i] = 2;
				continue;
			}
			List blocks = new ArrayList();
			for (int j = 0; j < written.length; j++)
				if (written[j])
					blocks.add(new Long(j));

			partialPieces.put((new StringBuilder()).append("").append(i).toString(), blocks);
		}

		resume_data.put("blocks", partialPieces);
		long lValid;
		if (check_interrupted)
			lValid = check_resume_was_valid ? 1L : 0L;
		else
		if (interim_save)
			lValid = 0L;
		else
			lValid = 1L;
		resume_data.put("valid", new Long(lValid));
		for (int i = 0; i < files.length; i++)
			files[i].flushCache();

		boolean is_complete = isTorrentResumeDataComplete(disk_manager.getDownloadManager().getDownloadState(), resume_data);
		if (!was_complete || !is_complete)
			saveResumeData(resume_data);
	}

	protected Map getResumeData()
	{
		return getResumeData(disk_manager.getDownloadManager());
	}

	protected static Map getResumeData(DownloadManager download_manager)
	{
		return getResumeData(download_manager.getDownloadState());
	}

	protected static Map getResumeData(DownloadManagerState download_manager_state)
	{
		Map resume_map = download_manager_state.getResumeData();
		if (resume_map != null)
		{
			Map resume_data = (Map)resume_map.get("data");
			return resume_data;
		} else
		{
			return null;
		}
	}

	protected void saveResumeData(Map resume_data)
	{
		saveResumeData(disk_manager.getDownloadManager().getDownloadState(), resume_data);
	}

	protected static void saveResumeData(DownloadManagerState download_manager_state, Map resume_data)
	{
		Map resume_map = new HashMap();
		resume_map.put("data", resume_data);
		download_manager_state.setResumeData(resume_map);
	}

	public static void setTorrentResumeDataComplete(DownloadManagerState download_manager_state)
	{
		TOTorrent torrent = download_manager_state.getTorrent();
		int piece_count = torrent.getNumberOfPieces();
		byte resume_pieces[] = new byte[piece_count];
		Arrays.fill(resume_pieces, (byte)1);
		Map resume_data = new HashMap();
		resume_data.put("resume data", resume_pieces);
		Map partialPieces = new HashMap();
		resume_data.put("blocks", partialPieces);
		resume_data.put("valid", new Long(1L));
		saveResumeData(download_manager_state, resume_data);
	}

	protected static int clearResumeDataSupport(DownloadManager download_manager, DiskManagerFileInfo file, boolean recheck, boolean onlyClearUnsharedFirstLast)
	{
		DownloadManagerState download_manager_state = download_manager.getDownloadState();
		Map resume_data = getResumeData(download_manager);
		if (resume_data == null)
			return 0;
		int pieces_cleared = 0;
		byte resume_pieces[] = (byte[])(byte[])resume_data.get("resume data");
		int firstPiece = file.getFirstPieceNumber();
		int lastPiece = file.getLastPieceNumber();
		if (onlyClearUnsharedFirstLast)
		{
			DiskManagerFileInfo files[] = download_manager.getDiskManagerFileInfo();
			boolean firstPieceShared = false;
			boolean lastPieceShared = false;
			int firstFile = findFirstFileWithPieceN(firstPiece, files);
			for (int i = firstFile; i < files.length; i++)
			{
				DiskManagerFileInfo currentFile = files[i];
				if (currentFile.getLastPieceNumber() < firstPiece || currentFile.getIndex() == file.getIndex())
					continue;
				if (currentFile.getFirstPieceNumber() > lastPiece)
					break;
				if (currentFile.getFirstPieceNumber() <= firstPiece && firstPiece <= currentFile.getLastPieceNumber())
					firstPieceShared |= !currentFile.isSkipped();
				if (currentFile.getFirstPieceNumber() <= lastPiece && lastPiece <= currentFile.getLastPieceNumber())
					lastPieceShared |= !currentFile.isSkipped();
			}

			if (firstPieceShared)
				firstPiece++;
			if (lastPieceShared)
				lastPiece--;
		}
		if (resume_pieces != null)
		{
			for (int i = firstPiece; i <= lastPiece && i < resume_pieces.length; i++)
			{
				if (resume_pieces[i] == 1)
					pieces_cleared++;
				resume_pieces[i] = ((byte)(recheck ? 2 : 0));
			}

		}
		Map partial_pieces = (Map)resume_data.get("blocks");
		if (partial_pieces != null)
		{
			Iterator iter = partial_pieces.keySet().iterator();
			do
			{
				if (!iter.hasNext())
					break;
				int piece_number = Integer.parseInt((String)iter.next());
				if (piece_number >= firstPiece && piece_number <= lastPiece)
					iter.remove();
			} while (true);
		}
		resume_data.put("valid", new Long(1L));
		saveResumeData(download_manager_state, resume_data);
		return pieces_cleared;
	}

	private static int findFirstFileWithPieceN(int firstPiece, DiskManagerFileInfo files[])
	{
		int pivot;
label0:
		{
			int start = 0;
			int end = files.length - 1;
			pivot = 0;
			do
			{
				if (start > end)
					break label0;
				pivot = start + end >>> 1;
				int midVal = files[pivot].getLastPieceNumber();
				if (midVal < firstPiece)
				{
					start = pivot + 1;
					continue;
				}
				if (midVal <= firstPiece)
					break;
				end = pivot - 1;
			} while (true);
			for (; pivot > 0 && files[pivot - 1].getLastPieceNumber() == firstPiece; pivot--);
		}
		return pivot;
	}

	public static boolean fileMustExist(DownloadManager download_manager, DiskManagerFileInfo file)
	{
		Map resumeData = getResumeData(download_manager);
		byte resumePieces[] = resumeData == null ? null : (byte[])(byte[])resumeData.get("resume data");
		boolean sharesAnyNeededPieces = false;
		DiskManagerFileInfo files[] = download_manager.getDiskManagerFileInfo();
		int firstPiece = file.getFirstPieceNumber();
		int lastPiece = file.getLastPieceNumber();
		int firstFile = findFirstFileWithPieceN(firstPiece, files);
		for (int i = firstFile; i < files.length && !sharesAnyNeededPieces; i++)
		{
			DiskManagerFileInfo currentFile = files[i];
			if (currentFile.getLastPieceNumber() < firstPiece)
				continue;
			if (currentFile.getIndex() == file.getIndex() && resumePieces != null && file.getStorageType() != 2)
			{
				for (int j = firstPiece; j <= lastPiece && !sharesAnyNeededPieces; j++)
					sharesAnyNeededPieces |= resumePieces[j] != 0;

			}
			if (currentFile.getFirstPieceNumber() > lastPiece)
				break;
			if (currentFile.getFirstPieceNumber() <= firstPiece && firstPiece <= currentFile.getLastPieceNumber())
				sharesAnyNeededPieces |= !currentFile.isSkipped();
			if (currentFile.getFirstPieceNumber() <= lastPiece && lastPiece <= currentFile.getLastPieceNumber())
				sharesAnyNeededPieces |= !currentFile.isSkipped();
		}

		return sharesAnyNeededPieces;
	}

	public static int storageTypeChanged(DownloadManager download_manager, DiskManagerFileInfo file)
	{
		return clearResumeDataSupport(download_manager, file, false, true);
	}

	public static void clearResumeData(DownloadManager download_manager, DiskManagerFileInfo file)
	{
		clearResumeDataSupport(download_manager, file, false, false);
	}

	public static void recheckFile(DownloadManager download_manager, DiskManagerFileInfo file)
	{
		clearResumeDataSupport(download_manager, file, true, false);
	}

	public static void setTorrentResumeDataNearlyComplete(DownloadManagerState download_manager_state)
	{
		TOTorrent torrent = download_manager_state.getTorrent();
		long piece_count = torrent.getNumberOfPieces();
		byte resume_pieces[] = new byte[(int)piece_count];
		Arrays.fill(resume_pieces, (byte)1);
		for (int i = 0; i < 3; i++)
		{
			int piece_num = (int)(Math.random() * (double)piece_count);
			resume_pieces[piece_num] = 2;
		}

		Map resumeMap = new HashMap();
		resumeMap.put("resume data", resume_pieces);
		Map partialPieces = new HashMap();
		resumeMap.put("blocks", partialPieces);
		resumeMap.put("valid", new Long(0L));
		saveResumeData(download_manager_state, resumeMap);
	}

	public static boolean isTorrentResumeDataComplete(DownloadManagerState dms)
	{
		Map resume_data = getResumeData(dms);
		return isTorrentResumeDataComplete(dms, resume_data);
	}

	protected static boolean isTorrentResumeDataComplete(DownloadManagerState download_manager_state, Map resume_data)
	{
		int piece_count;
		byte pieces[];
		Map blocks;
		boolean valid;
		piece_count = download_manager_state.getTorrent().getNumberOfPieces();
		if (resume_data == null)
			break MISSING_BLOCK_LABEL_137;
		pieces = (byte[])(byte[])resume_data.get("resume data");
		blocks = (Map)resume_data.get("blocks");
		valid = ((Long)resume_data.get("valid")).intValue() == 1;
		if (blocks == null || blocks.size() > 0)
			return false;
		int i;
		if (!valid || pieces == null || pieces.length != piece_count)
			break MISSING_BLOCK_LABEL_137;
		i = 0;
_L1:
		if (i >= pieces.length)
			break MISSING_BLOCK_LABEL_127;
		if (pieces[i] != 1)
			return false;
		i++;
		  goto _L1
		return true;
		Throwable e;
		e;
		Debug.printStackTrace(e);
		return false;
	}

	static 
	{
		LOGID = LogIDs.DISK;
		COConfigurationManager.addAndFireParameterListeners(new String[] {
			"Use Resume", "On Resume Recheck All"
		}, new ParameterListener() {

			public void parameterChanged(String str)
			{
				RDResumeHandler.use_fast_resume = COConfigurationManager.getBooleanParameter("Use Resume");
				RDResumeHandler.use_fast_resume_recheck_all = COConfigurationManager.getBooleanParameter("On Resume Recheck All");
			}

		});
	}


}