internal void callProgressChanged(queue queue)
{
if (ProgressChanged != null)
{
ProgressChanged(this, queue);
}
}
public void QueueTransfer(string fileName)
{
try
{
//We will create our upload queue.
queue queue = queue.CreateUploadQueue(this, fileName);
//Add the transfer to our transfer list.
_transfers.Add(queue.ID, queue);
//Now we will create and build our queue packet.
PacketWriter pw = new PacketWriter();
pw.Write((byte)Headers.Queue);
pw.Write(queue.ID);
pw.Write(queue.Typefile);
pw.Write(queue.Filename);
pw.Write(queue.Length);
Send(pw.GetBytes());
//Call queued
if (Queued != null)
{
Queued(this, queue);
}
}
catch
{
}
}
public static queue CreateDownloadQueue(Tranferclint client, int id, string trpe, string SName, string saveName, long length)
{
try
{
//Same as above with some changes.
var queue = new queue();
queue.Filename = Path.GetFileName(saveName);
queue.Shortename = SName;
queue.Client = client;
queue.Type = QueueType.Download;
//Create our file stream for writing.
queue.FS = new FileStream(saveName, FileMode.Create);
//Fill the stream will 0 bytes based on the real size. So we can index write.
queue.Length = length;
queue.FS.SetLength(length);
// queue.Length = length;
//Instead of generating an ID, we will set the ID that has been sent.
queue.ID = id;
return(queue);
}
catch
{
return(null);
}
}
public static queue CreateUploadQueue(Tranferclint client, string fileName)
{
try
{
//We will create a new upload queue
var queue = new queue();
//Set our filename
queue.Filename = Path.GetFileName(fileName);
queue.Typefile = Path.GetFileName(fileName).ToLower().Contains("jpg") || Path.GetFileName(fileName).ToLower().Contains("png") ? "Image":"Video";
// queue._Type = "image";
//Set our client
queue.Client = client;
//Set our queue type to upload.
queue.Type = QueueType.Upload;
//Create our file stream for reading.
queue.FS = new FileStream(fileName, FileMode.Open);
//Create our transfer thread
queue.Thread = new Thread(new ParameterizedThreadStart(transferProc));
// queue.Thread.IsBackground = true;
//Generate our ID
queue.ID = Program.Rand.Next();
//Set our length to the size of the file.
queue.Length = queue.FS.Length;
return(queue);
}
catch
{
//If something goes wrong, return null
return(null);
}
}
public void StartTransfer(queue queue)
{
//We'll create our start packet.
PacketWriter pw = new PacketWriter();
pw.Write((byte)Headers.Start);
pw.Write(queue.ID);
Send(pw.GetBytes());
}
private void TransferClient_ProgressChanged(object sender, queue queue)
{
if (InvokeRequired)
{
Invoke(new TransferEventHandler(TransferClient_ProgressChanged), sender, queue);
return;
}
// listfiles.Items[queue.ID.ToString()].SubItems[2].Text = queue.Progress + "%";
progessing(queue);
}
private void AddViewItem(string Namefile, string type, string pros, queue q)
{
ListViewItem item = new ListViewItem(Namefile);
item.SubItems.Add(type);
item.SubItems.Add("0% " + pros);
listfiles.Items.Add(item);
item.Tag = q; //Set the tag to queue so we can grab is easily.
item.Name = q.ID.ToString();
AddIhem++;
}
private void existIthem(queue queue)// check were is name file in Listview to dowload
{
for (int i = 0; i < listfiles.Items.Count; i++)
{
if (Path.GetFileName(queue.Filename) == listfiles.Items[i].SubItems[0].Text)
{
listfiles.Items[i].Tag = queue; //Set the tag to queue so we can grab is easily.
listfiles.Items[i].Name = queue.ID.ToString();
listfiles.Items[i].SubItems[2].Text = "0% Downloading";
}
}
}
private void TransferClient_Complete(object sender, queue queue)
{
bool finsh = false;
foreach (queue q in queueList)
{
if (q.Progress == 100 || !q.Running)
{
finsh = true;
}
else
{
finshQ = false;
finsh = false;
break;
}
}
if (finsh)
{
finshQ = true;
queueList.Clear();
if (queue.Filename != "list.json")
{
if (TowDirectory)
{
creat_to_Directory();
}
Process.Start(outputFolder);
}
File.Delete(outputFolder + "\\commad.json");
chekconnction = true;
// if (queue.Filename != "list.json") { if (Refresh) { freah = true; } }
}
}
private void finsh_Progress()
{
bool uploade = false;
foreach (ListViewItem item in listfiles.Items)
{
try
{
queue _queue = (queue)item.Tag;
if (_queue != null)
{
if (_queue.Progress == 100 || !_queue.Running)
{
uploade = true;
} // if (_queue.Progress == 100 || !_queue.Running)
else
{
uploade = false; break;
} //else (_queue.Progress == 100 || !_queue.Running)
} // if (_queue != null)
}
catch { }
}
if (uploade)
{
beginprogress = false;
//begin to Refreah auto
if (Refresh)
{
freah = true;
}
}
}
// private Tranferclint transferClient=new Tranferclint;
private void TransferClient_Queued(object sender, queue queue)
{
beginprogress = true;//begin progrsses
chekconnction = false;
if (InvokeRequired)
{
Invoke(new TransferEventHandler(TransferClient_Queued), sender, queue);
return;
}
// string namefile = Path.GetFileName(file);
// string typefile = Path.GetExtension(file).ToLower().Contains("jpg") || Path.GetExtension(file).ToLower().Contains("png") ? "Image" : "Video";
string type = queue.Type == QueueType.Download ? "Download" : "Upload";
if (type == "Upload")
{
if (Path.GetFileName(queue.Filename) != "commad.json")
{
AddViewItem(queue.Filename, queue.Typefile, type, queue);
}
}
if (queue.Type == QueueType.Download)
{
transferClient.StartTransfer(queue);
existIthem(queue);
queueList.Add(queue);
}
}
private void progessing(queue queue)
{
try
{
// for (int i = 0; i < queueList.Count; i++)
// {
// for (int j = 0; j < listfiles.Items.Count; j++)
// if (listfiles.Items[j].SubItems[0].Text == Path.GetFileName(queueList[i].Filename))
// {
if (queue.Filename != "list.json" & queue.Filename != "commad.json")
{
try
{
listfiles.Items[queue.ID.ToString()].UseItemStyleForSubItems = false;
listfiles.Items[queue.ID.ToString()].SubItems[2].ForeColor = queue.Type == QueueType.Download ? System.Drawing.Color.Brown : System.Drawing.Color.Blue;
string type = queue.Type == QueueType.Download ? "Downloading" : "Uploading";
//listfiles.Items[j].SubItems[2].Text = queue.Progress.ToString() + "%" + type;
listfiles.Items[queue.ID.ToString()].SubItems[2].Text = queue.Progress + "%" + type;
// uploade = false;
}
catch { }
}
if (queue.Progress == 100 || !queue.Running)
{
if (queue.Filename == Path.GetFileName("list.json"))
{
// uploade = true;
readbool = true;
}
else
{
// uploade = true;
if (queue.Filename != "list.json" & queue.Filename != "commad.json")
{
listfiles.Items[queue.ID.ToString()].UseItemStyleForSubItems = false;
listfiles.Items[queue.ID.ToString()].SubItems[2].ForeColor = System.Drawing.Color.Green;
listfiles.Items[queue.ID.ToString()].SubItems[2].Text = " 100% Complete";
}
// bool uploade = false;
}
}
}
//}
catch { }
}
private void TransferClient_Stopped(object sender, queue queue)
{
// if(i==0)
queueList.Clear();
}
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();
string type = pr.ReadString();
long length = pr.ReadInt64();
//Create our queueload queue.
queue queue = queue.CreateDownloadQueue(this, id, type, Path.GetFileName(fileName), 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.
queue 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.
queue 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.
queue queue = (queue)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)4);
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.
}
