//-------------------------------------------------------------
public void pieceHashedDelegate(object o, PieceHashedEventArgs e)
//-------------------------------------------------------------
{
if (e != null && o != null)
{
TorrentManager torrentManager = (TorrentManager)o;
if (torrentManager.State == TorrentState.Stopped)
{
return;
}
if (kobberLan != null && e.TorrentManager != null && e.TorrentManager.Torrent != null)
{
kobberLan.Invoke(new Action(() =>
{
bool status = kobberLan.UpdateProgressBar(TorrentState.Hashing, (int)(e.Progress * 100.0), e.TorrentManager.Torrent.Name); // e.TorrentManager.State
if (status == false)
{
torrentManager.PieceHashed -= pieceHashedDelegate;
torrentManager.StopAsync();
Log.Get().Write("PieceHashed failed", Log.LogType.Error);
}
}));
}
}
}
private void PieceHashed(object sender, PieceHashedEventArgs e)
{
if (e.TorrentManager.State != TorrentState.Hashing)
{
DiskManager.QueueFlush(e.TorrentManager, e.PieceIndex);
}
}
internal void HashedPiece(PieceHashedEventArgs pieceHashedEventArgs)
{
if (!pieceHashedEventArgs.HashPassed)
{
Interlocked.Increment(ref _hashFails);
}
RaisePieceHashed(pieceHashedEventArgs);
}
public static void HandlePieceHashed(object sender, PieceHashedEventArgs e)
{
var torrentManager = e.TorrentManager;
if (torrentManager.State == TorrentState.Downloading && e.HashPassed)
{
logger.DebugFormat("Torrent {0}: downloaded piece {1}.",
torrentManager.Torrent.Name, e.PieceIndex);
}
}
private void OnPieceHashed(object sender, PieceHashedEventArgs e)
{
float progress = EnumAdapter.Adapt(manager.State) == TorrentState.Hashing ? (float)e.PieceIndex / manager.Bitfield.Length : 1;
PieceHashedHandler h = PieceHashed;
if (h != null)
{
h(Path, e.PieceIndex, e.HashPassed, progress);
}
}
void wrapper_PieceHashed(object sender, PieceHashedEventArgs e)
{
if (RecievedPieces == null)
{
RecievedPieces = new bool[Torrent.Torrent.Pieces.Count];
for (int i = 0; i < RecievedPieces.Length; i++)
{
RecievedPieces[i] = false;
}
}
if (e.HashPassed)
{
RecievedPieces[e.PieceIndex] = true;
}
}
private void manager_PieceHashed(object sender, PieceHashedEventArgs args)
{
try {
if (manager.State == TorrentState.Hashing)
{
hashingPercent = ((args.PieceIndex / (double)manager.Torrent.Pieces.Count) * 100);
}
#if RIDICULOUS_DEBUG_OUTPUT
LoggingService.LogDebug("Piece Hashed!");
#endif
} catch (Exception ex) {
LoggingService.LogError("Error in manager_PieceHashed.", ex);
Cancel();
}
}
public async Task OnPieceHashed(object sender, PieceHashedEventArgs eventArgs)
{
if (!eventArgs.HashPassed)
{
return;
}
_hashedPieces.Add(eventArgs.PieceIndex);
if (_parser is null)
{
return;
}
await GetDoc();
if (_document?.Body is null || _document?.Head is null)
{
return;
}
await ParseDocument();
}
private void OnPieceHashed(object sender, PieceHashedEventArgs args)
{
if (!hashProgress.ContainsKey(args.TorrentManager))
{
hashProgress.Add(args.TorrentManager, 0);
}
else
{
hashProgress[args.TorrentManager] = (int)((args.PieceIndex / (float)args.TorrentManager.Torrent.Pieces.Count) * 100);
}
// remove hashed piece from pieces
foreach (BlockEventArgs blockEvent in pieces)
{
if (blockEvent.Piece.Index != args.PieceIndex)
{
pieces.Remove(blockEvent);
return;
}
}
}
internal void RaisePieceHashed(PieceHashedEventArgs args)
{
var index = args.PieceIndex;
var files = Torrent.Files;
foreach (var t in files.Where(t => index >= t.StartPieceIndex && index <= t.EndPieceIndex))
{
t.BitField[index - t.StartPieceIndex] = args.HashPassed;
}
if (args.HashPassed)
{
var connected = Peers.ConnectedPeers;
foreach (var t in connected)
{
t.IsAllowedFastPieces.Remove(index);
}
}
Toolbox.RaiseAsyncEvent(PieceHashed, this, args);
}
