public void StopTransfer(TransferQueue queue) { //If we're the uploading transfer, we'll just stop it. if (queue.Type == QueueType.Upload) { queue.Stop(); } PacketWriter pw = new PacketWriter(); pw.Write((byte)Headers.Stop); pw.Write(queue.ID); Send(pw.GetBytes()); //Don't forget to close the queue. queue.Close(); }
private void process() { PacketReader pr = new PacketReader(_buffer); //Create our packet reader. Headers header = (Headers)pr.ReadByte(); //Read and cast our header. switch (header) { case Headers.Queue: { //Read the ID, Filename and length of the file (For progress) from the packet. int id = pr.ReadInt32(); string fileName = pr.ReadString(); long length = pr.ReadInt64(); //Create our download queue. TransferQueue queue = TransferQueue.CreateDownloadQueue(this, id, Path.Combine(OutputFolder, Path.GetFileName(fileName)), length); //Add it to our transfer list. _transfers.Add(id, queue); //Call queued. if (Queued != null) { Queued(this, queue); } } break; case Headers.Start: { //Read the ID int id = pr.ReadInt32(); //Start the upload. if (_transfers.ContainsKey(id)) { _transfers[id].Start(); } } break; case Headers.Stop: { //Read the ID int id = pr.ReadInt32(); if (_transfers.ContainsKey(id)) { //Get the queue. TransferQueue queue = _transfers[id]; //Stop and close the queue queue.Stop(); queue.Close(); //Call the stopped event. if (Stopped != null) { Stopped(this, queue); } //Remove the queue _transfers.Remove(id); } } break; case Headers.Pause: { int id = pr.ReadInt32(); //Pause the upload. if (_transfers.ContainsKey(id)) { _transfers[id].Pause(); } } break; case Headers.Chunk: { //Read the ID, index, size and buffer from the packet. int id = pr.ReadInt32(); long index = pr.ReadInt64(); int size = pr.ReadInt32(); byte[] buffer = pr.ReadBytes(size); //Get the queue. TransferQueue queue = _transfers[id]; //Write the newly transferred bytes to the queue based on the write index. queue.Write(buffer, index); //Get the progress of the current transfer with the formula //(AMOUNT_TRANSFERRED * 100) / COMPLETE SIZE queue.Progress = (int)((queue.Transferred * 100) / queue.Length); //This will prevent the us from calling progress changed multiple times. /* Such as * 2, 2, 2, 2, 2, 2 (Since the actual progress minus the decimals will be the same for a bit * It will be * 1, 2, 3, 4, 5, 6 * Instead*/ if (queue.LastProgress < queue.Progress) { queue.LastProgress = queue.Progress; if (ProgressChanged != null) { ProgressChanged(this, queue); } //If the transfer is complete, call the event. if (queue.Progress == 100) { queue.Close(); if (Complete != null) { Complete(this, queue); } } } } break; } pr.Dispose(); //Dispose the reader. }
private static void transferProc(object o) { //Cast our transfer queue from the parameter. TransferQueue queue = (TransferQueue)o; //If Running is true, the thread will keep going //If queue.Index is not the file length, the thread will continue. while (queue.Running && queue.Index < queue.Length) { //We will call WaitOne to see if we're paused or not. //If we are, it will block until notified. queue.pauseEvent.WaitOne(); //Just in case the transfer was paused then stopped, check to see if we're still running if (!queue.Running) { break; } //Lock the file buffer so only one queue can use it at a time. lock (file_buffer) { //Set the read position to our current position queue.FS.Position = queue.Index; //Read a chunk into our buffer. int read = queue.FS.Read(file_buffer, 0, file_buffer.Length); //Create our packet writer and send our chunk packet. PacketWriter pw = new PacketWriter(); pw.Write((byte)Headers.Chunk); pw.Write(queue.ID); pw.Write(queue.Index); pw.Write(read); pw.Write(file_buffer, 0, read); /*The reason the buffer size is 8175 is so it'll be about 8 kilobytes * It should be 8192, but its 8191. I missed a byte since I had to make a quick change, but eh. * 4 Bytes = ID * 8 Bytes = Index * 4 Bytes = read * 8175 Bytes = file_buffer * All together (If the file buffer is full) 8192 Bytes * */ //Increase our data transffered and read index. queue.Transferred += read; queue.Index += read; //Send our data queue.Client.Send(pw.GetBytes()); //Get our progress queue.Progress = (int)((queue.Transferred * 100) / queue.Length); if (queue.LastProgress < queue.Progress) { queue.LastProgress = queue.Progress; queue.Client.callProgressChanged(queue); } //Sleep for a millisecond so we don't kill our CPU Thread.Sleep(1); } } queue.Close(); //Once the loop is broken, close the queue. }