private void OnFileTransferStateChanged(FileTransferState state, FileTransferStateChangeReason reason)
{
Console.WriteLine(MSG_PREFIX + "OnFileTransferStateChanged: state {0}, reason {1}",
state.ToString(), reason.ToString());
switch (state)
{
case FileTransferState.Open:
s = new System.Net.Sockets.Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.IP);
EndPoint ep = new UnixEndPoint(socket_addr);
s.Connect(ep);
if (transfer_initiator == self_handle)
{
Console.WriteLine(MSG_PREFIX + "Sending file");
ThreadPool.QueueUserWorkItem(delegate { SendFile(); });
}
else
{
Console.WriteLine(MSG_PREFIX + "Receiving file");
ThreadPool.QueueUserWorkItem(delegate { ReceiveFile(); });
}
break;
case FileTransferState.Completed:
Console.WriteLine(MSG_PREFIX + "Transfer completed.");
ift.Close();
break;
}
}
private void OnFileTransferStateChanged(FileTransferState state, FileTransferStateChangeReason reason)
{
//Console.WriteLine ("OnFileTransferStateChanged: state {0}", state);
switch (state)
{
case FileTransferState.Open:
if (pf_result != null)
{
address = pf_caller.EndInvoke(pf_result);
pf_result = null;
}
OnChannelReady(EventArgs.Empty);
break;
case FileTransferState.Completed:
Close();
break;
case FileTransferState.Cancelled:
Close();
break;
}
}
private void StopTransfer(string trID, FileTransferState newState, bool isOutgoing)
{
TransferItem fileTransfer;
SendData(TransferCommands.StopTransfer + TRANSFERS_COMMAND_SEPARATOR +
(int)newState + TRANSFERS_COMMAND_SEPARATOR +
"1" + TRANSFERS_COMMAND_SEPARATOR + trID + TRANSFERS_COMMAND_SEPARATOR);
fileTransfer = isOutgoing ? outgoing.GetTransferItem(trID) : incoming.GetTransferItem(trID);
if (fileTransfer != null)
{
List <ITransferItem> tempList = new List <ITransferItem>();
tempList.Add(fileTransfer);
if (fileStreams.ContainsKey(fileTransfer.TrId) && fileStreams[fileTransfer.TrId] != null)
{
incoming.TransferedBytes += fileTransfer.FileSize - fileStreams[fileTransfer.TrId].Position;
}
OnTransferError(new TransferErrorEventArgs(tempList, fileTransfer.OtherSideURI, newState, !isOutgoing));
if (isOutgoing)
{
outgoing.CurrentIndex++;
}
else
{
incoming.CurrentIndex++;
}
FinalizeTransfer(fileTransfer, newState);
}
}
private void FinalizeTransfer(string trId, FileTransferState newState)
{
TransferItem finalizingTransfer =
incoming.GetTransferItem(trId) == null?outgoing.GetTransferItem(trId) : incoming.GetTransferItem(trId);
FinalizeTransfer(finalizingTransfer, newState);
}
/// <summary>
/// Starts file read (download from device) operation
/// </summary>
/// <param name="in_file_name"></param>
public void FileDownloadStart(string in_file_name, FileTransferCallback in_callback)
{
// sanity check
if (m_file_transfer_state != FileTransferState.Idle)
{
throw new Exception("File transfer already pending.");
}
// initialize file transfer info
m_file_transfer_callback = in_callback;
m_file_transfer_state = FileTransferState.ReadInfo;
m_file_transfer_current_name = in_file_name;
m_file_transfer_current_position = 0;
m_file_transfer_current_size = 0;
UpdateFileTransferState();
// file info packet
PacketFileInfoRequest request_packet = new PacketFileInfoRequest();
request_packet.FileName = in_file_name;
FileOperationStart(request_packet, null);
}
/// <summary>
/// Starts file write (upload to the device) operation
/// </summary>
/// <param name="in_file_id"></param>
/// <param name="in_file_pos"></param>
/// <param name="in_data"></param>
/// <param name="in_callback"></param>
/// <returns></returns>
public void FileUploadStart(byte in_file_id, UInt32 in_file_pos, byte[] in_data, FileTransferCallback in_callback)
{
// sanity check
if (m_file_transfer_state != FileTransferState.Idle)
{
throw new Exception("File transfer already pending.");
}
// init file transfer
m_file_transfer_callback = in_callback;
m_file_transfer_state = FileTransferState.WriteData;
m_file_transfer_current_position = in_file_pos;
m_file_transfer_current_id = in_file_id;
// create write packet
PacketFileDataWriteRequestHeader request_packet;
// create file write packet
request_packet = new PacketFileDataWriteRequestHeader((byte)in_data.Length);
request_packet.ID = m_file_transfer_current_id;
request_packet.Pos = m_file_transfer_current_position;
// starts file operation
FileOperationStart(request_packet, in_data, null);
}
private void TryPauseTransfer()
{
if (State != FileTransferState.Uploading && State != FileTransferState.Downloading)
{
return;
}
State = FileTransferState.PausedByFriend;
}
/// <summary>
/// Processes received file data write response
/// </summary>
private void ProcessFileDataWriteResponse()
{
string file_operation_id;
PendingFileOperationInfo file_operation_info;
PacketFileDataWriteResponse packet = (PacketFileDataWriteResponse)CommunicationManager.Default.ReceiverQueue.Pop(typeof(PacketFileDataWriteResponse));
CommunicationManager.Default.PacketLogWrite("R", packet);
// check file operation ID
file_operation_id = packet.FileOperationID;
if (!m_pending_file_operations.ContainsKey(file_operation_id))
{
return;
}
// check pending file operation
file_operation_info = m_pending_file_operations[file_operation_id];
if (file_operation_info.Packet.PacketType != PacketType.FileDataWriteRequest)
{
return;
}
// remove file operation from the peding list
FileOperationEnd(packet);
// if no callback if defined, this is regular system file operation
if (file_operation_info.Callback == null)
{
// file transfer state: idle
m_file_transfer_state = FileTransferState.Idle;
if (packet.ID == InvalidSystemFileID)
{
// if file not found -> error
CallFileTransferFinishedCallback(new FileTransferResultInfo(FileTransferResult.NotFound));
}
else
{
if (packet.Error == 0)
{
// call transfer callback
CallFileTransferFinishedCallback(new FileTransferResultInfo(FileTransferResult.Success, m_file_transfer_current_id, ""));
}
else
{
// call transfer callback
CallFileTransferFinishedCallback(new FileTransferResultInfo(FileTransferResult.Error));
}
}
}
else
{
file_operation_info.Callback(packet);
}
}
private void OnEndFileTransfer()
{
_fileTransferState = FileTransferState.None;
// Returns reconstructed received file data to event listeners
if (ReceiveFileFinished != null)
{
byte[] data = _fileMemoryStream.ToArray();
ReceiveFileFinished(data);
}
}
public void ClearAllTransfers(FileTransferState clearingState)
{
while (incoming.Files.Count > 0)
{
FinalizeTransfer(Incoming.Files[0].TrId, clearingState);
}
while (outgoing.Files.Count > 0)
{
FinalizeTransfer(outgoing.Files[0].TrId, clearingState);
}
}
private void OnStartFileTransfer(int fileSize)
{
_fileTransferState = FileTransferState.Receiving;
// Notify event listener about start of file receival
if (ReceiveFileStarted != null)
{
ReceiveFileStarted(fileSize);
}
// Allocate a temporary memory stream for incoming file
_fileMemoryStream = new MemoryStream(fileSize);
}
public void PauseTransfer()
{
if (State != FileTransferState.Downloading && State != FileTransferState.Uploading)
{
return;
}
var successfulSend = _toxModel.FileControl(_friendNumber, _fileNumber, ToxFileControl.Pause);
if (successfulSend)
{
State = FileTransferState.PausedByUser;
}
}
/// <summary>
/// Initiates transfer of <paramref name="data"/> to all other players.
/// </summary>
/// <param name="data">
/// The data to transfer.
/// </param>
/// <param name="chunkSize">
/// The size of chunks to split the file into.
/// </param>
public void TransmitFile(byte[] data, int chunkSize) {
if (_fileTransferState != FileTransferState.None) {
throw new IOException("File transfer already in progress");
}
_fileTransferState = FileTransferState.Transmitting;
int dataSize = data.Length;
int transmittedSize = 0;
// Calculate number of chunks
int chunksCount = data.Length / chunkSize + 1;
// Notify listeners that transfer has started
if (TransmitFileStarted != null)
TransmitFileStarted(dataSize);
// Send an RPC to notify other players about start of transfer
_networkView.RPC("OnStartFileTransfer", RPCMode.Others, dataSize);
for (int i = 0; i < chunksCount; i++) {
// Calculate size of current chunk. It is usually smaller than chunkSize
// for the last chunk
int currentChunkSize = chunkSize;
if (transmittedSize + chunkSize > dataSize) {
currentChunkSize = dataSize - transmittedSize;
if (currentChunkSize == 0)
break;
}
// Allocate an array for a chunk, fill it and send over network
byte[] chunk = new byte[currentChunkSize];
Array.Copy(data, transmittedSize, chunk, 0, currentChunkSize);
_networkView.RPC("ProcessFileChunk", RPCMode.Others, chunk);
transmittedSize += currentChunkSize;
// Notify listeners about new chunk transfer
if (TransmitFileChunk != null)
TransmitFileChunk(dataSize);
}
// Send an RPC to notify other players about end of transfer
_networkView.RPC("OnEndFileTransfer", RPCMode.Others);
_fileTransferState = FileTransferState.None;
// Notify event listeners about end of transfer
if (TransmitFileFinished != null)
TransmitFileFinished();
}
private void FileChunkReceivedHandler(object sender, ToxEventArgs.FileChunkEventArgs e)
{
if (IsPlaceholder || !IsThisTransfer(e))
{
return;
}
PutNextChunk(e);
if (IsFinished)
{
_fileTransferResumer.RemoveTransfer(_friendNumber, _fileNumber);
State = FileTransferState.Finished;
}
}
private void ProcessFileChunk(byte[] data)
{
// Check if we can receive a chunk
if (_fileTransferState != FileTransferState.Receiving)
{
_fileTransferState = FileTransferState.None;
Debug.LogError("Received a file chunk when not in receival mode");
return;
}
// Notify event listeners about new incoming chunk
if (ReceiveFileChunk != null)
{
ReceiveFileChunk(data.Length);
}
// Save chunk data
_fileMemoryStream.Write(data, 0, data.Length);
}
private void FileChunkRequestedHandler(object sender, ToxEventArgs.FileRequestChunkEventArgs e)
{
if (IsPlaceholder || !IsThisTransfer(e))
{
return;
}
var chunk = GetNextChunk(e);
var successfulChunkSend = _toxModel.FileSendChunk(e.FriendNumber, e.FileNumber, e.Position, chunk);
if (successfulChunkSend)
{
if (IsFinished)
{
_fileTransferResumer.RemoveTransfer(_friendNumber, _fileNumber);
State = FileTransferState.Finished;
}
}
}
public async Task AcceptTransfer(StorageFile file)
{
var fileStream = (await file.OpenAsync(FileAccessMode.ReadWrite)).AsStream();
// Replace the dummy stream set previously in FileSendRequestReceivedHandler():
ReplaceStream(fileStream);
var successfulSend = _toxModel.FileControl(_friendNumber, _fileNumber, ToxFileControl.Resume);
if (successfulSend)
{
_fileTransferResumer.RecordTransfer(file, _friendNumber, _fileNumber, TransferDirection.Down);
State = FileTransferState.Downloading;
}
else
{
ReplaceStream(null);
fileStream.Dispose();
}
}
internal bool FireTransferEvent(FileTransferState state, String filename, long bytes)
{
try
{
if (TransferEvents != null)
{
return(TransferEvents(state, filename, bytes));
}
else
{
return(true);
}
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine("WARNING! Exception caught in Maverick.NET event handler: " + ex.Message);
System.Diagnostics.Trace.WriteLine(ex.StackTrace);
return(true);
}
}
private void FileControlReceivedHandler(object sender, ToxEventArgs.FileControlEventArgs e)
{
if (IsPlaceholder || !IsThisTransfer(e))
{
return;
}
switch (e.Control)
{
case ToxFileControl.Cancel:
_fileTransferResumer.RemoveTransfer(_friendNumber, _fileNumber);
State = FileTransferState.Cancelled;
return;
case ToxFileControl.Pause:
TryPauseTransfer();
return;
case ToxFileControl.Resume:
TryResumeTransfer();
return;
}
}
private void FinalizeTransfer(TransferItem finalizingTransfer, FileTransferState newState)
{
if (finalizingTransfer == null)
{
return;
}
if (finalizingTransfer.State != newState)
{
finalizingTransfer.State = newState;
}
if (fileStreams.ContainsKey(finalizingTransfer.TrId) && fileStreams[finalizingTransfer.TrId] != null)
{
fileStreams[finalizingTransfer.TrId].Close();
}
fileStreams.Remove(finalizingTransfer.TrId);
incoming.RemoveTransferItem(finalizingTransfer);
outgoing.RemoveTransferItem(finalizingTransfer);
if (incoming.Files.Count == 0)
{
incoming.Initialize();
}
if (outgoing.Files.Count == 0)
{
outgoing.Initialize();
}
List <ITransferItem> tempList = new List <ITransferItem>();
tempList.Add(finalizingTransfer);
OnTransferEnded(new TransfersManagerEventArgs(tempList, finalizingTransfer.OtherSideURI));
}
public FileTransferManager()
{
m_pending_file_operations = new Dictionary <string, PendingFileOperationInfo>();
m_file_transfer_state = FileTransferState.Idle;
m_file_transfer_current_file = null;
}
public void PauseTransfer()
{
if (State != FileTransferState.Downloading && State != FileTransferState.Uploading)
return;
var successfulSend = ToxModel.Instance.FileControl(_friendNumber, _fileNumber, ToxFileControl.Pause);
if (successfulSend)
{
State = FileTransferState.PausedByUser;
}
}
public async Task AcceptTransfer(StorageFile file)
{
var fileStream = (await file.OpenAsync(FileAccessMode.ReadWrite)).AsStream();
// Replace the dummy stream set previously in FileSendRequestReceivedHandler():
ReplaceStream(fileStream);
var successfulSend = ToxModel.Instance.FileControl(_friendNumber, _fileNumber, ToxFileControl.Resume);
if (successfulSend)
{
FileTransferResumer.Instance.RecordTransfer(file, _friendNumber, _fileNumber, TransferDirection.Down);
State = FileTransferState.Downloading;
}
else
{
ReplaceStream(null);
fileStream.Dispose();
}
}
private void FileChunkReceivedHandler(object sender, ToxEventArgs.FileChunkEventArgs e)
{
if (IsPlaceholder || !IsThisTransfer(e))
return;
PutNextChunk(e);
if (IsFinished)
{
FileTransferResumer.Instance.RemoveTransfer(_friendNumber, _fileNumber);
State = FileTransferState.Finished;
}
}
private void FileChunkRequestedHandler(object sender, ToxEventArgs.FileRequestChunkEventArgs e)
{
if (IsPlaceholder || !IsThisTransfer(e))
return;
var chunk = GetNextChunk(e);
var successfulChunkSend = ToxModel.Instance.FileSendChunk(e.FriendNumber, e.FileNumber, e.Position, chunk);
if (successfulChunkSend)
{
if (IsFinished)
{
FileTransferResumer.Instance.RemoveTransfer(_friendNumber, _fileNumber);
State = FileTransferState.Finished;
}
}
}
/// <summary>
/// Initiates transfer of <paramref name="data"/> to all other players.
/// </summary>
/// <param name="data">
/// The data to transfer.
/// </param>
/// <param name="chunkSize">
/// The size of chunks to split the file into.
/// </param>
public void TransmitFile(byte[] data, int chunkSize)
{
if (_fileTransferState != FileTransferState.None)
{
throw new IOException("File transfer already in progress");
}
_fileTransferState = FileTransferState.Transmitting;
int dataSize = data.Length;
int transmittedSize = 0;
// Calculate number of chunks
int chunksCount = data.Length / chunkSize + 1;
// Notify listeners that transfer has started
if (TransmitFileStarted != null)
{
TransmitFileStarted(dataSize);
}
// Send an RPC to notify other players about start of transfer
_networkView.RPC("OnStartFileTransfer", RPCMode.Others, dataSize);
for (int i = 0; i < chunksCount; i++)
{
// Calculate size of current chunk. It is usually smaller than chunkSize
// for the last chunk
int currentChunkSize = chunkSize;
if (transmittedSize + chunkSize > dataSize)
{
currentChunkSize = dataSize - transmittedSize;
if (currentChunkSize == 0)
{
break;
}
}
// Allocate an array for a chunk, fill it and send over network
byte[] chunk = new byte[currentChunkSize];
Array.Copy(data, transmittedSize, chunk, 0, currentChunkSize);
_networkView.RPC("ProcessFileChunk", RPCMode.Others, chunk);
transmittedSize += currentChunkSize;
// Notify listeners about new chunk transfer
if (TransmitFileChunk != null)
{
TransmitFileChunk(dataSize);
}
}
// Send an RPC to notify other players about end of transfer
_networkView.RPC("OnEndFileTransfer", RPCMode.Others);
_fileTransferState = FileTransferState.None;
// Notify event listeners about end of transfer
if (TransmitFileFinished != null)
{
TransmitFileFinished();
}
}
/// <summary>
/// Processes file information response packet
/// </summary>
private void ProcessFileInfoResponse()
{
string file_operation_id;
PendingFileOperationInfo file_operation_info;
PacketFileInfoResponse packet = (PacketFileInfoResponse)CommunicationManager.Default.ReceiverQueue.Pop(typeof(PacketFileInfoResponse));
CommunicationManager.Default.PacketLogWrite("R", packet);
// check file operation ID
file_operation_id = packet.FileOperationID;
if (!m_pending_file_operations.ContainsKey(file_operation_id))
{
return;
}
// check pending file operation
file_operation_info = m_pending_file_operations[file_operation_id];
if (file_operation_info.Packet.PacketType != PacketType.FileInfoRequest)
{
return;
}
// remove file operation from the peding list
FileOperationEnd(packet);
// if no callback if defined, this is regular system file operation
if (file_operation_info.Callback == null)
{
if (packet.ID == InvalidSystemFileID)
{
// if file not found -> error
m_file_transfer_state = FileTransferState.Idle;
CallFileTransferFinishedCallback(new FileTransferResultInfo(FileTransferResult.NotFound));
}
else
{
m_file_transfer_current_position = 0;
m_file_transfer_current_size = packet.Length;
m_file_transfer_current_id = packet.ID;
string cached_file_name = m_file_transfer_current_name + "[" + CommunicationManager.Default.ConnectedDeviceUniqueID.ToString("x4") + "]";
// file exists -> check file in the cache
if (DeviceFileCache.IsFileExists(cached_file_name, packet.Length, packet.Hash))
{
// file exists in the cache -> call callback with success code
string file_path;
file_path = Path.Combine(DeviceFileCache.GetFileCachePath(), cached_file_name);
m_file_transfer_current_position = m_file_transfer_current_size;
m_file_transfer_state = FileTransferState.Idle;
UpdateFileTransferState();
CallFileTransferFinishedCallback(new FileTransferResultInfo(FileTransferResult.Success, m_file_transfer_current_id, file_path));
}
else
{
// file doesn't exists in the cache create file in the cache and download it
m_file_transfer_current_file = DeviceFileCache.CreateFile(cached_file_name, 0);
// start download
m_file_transfer_state = FileTransferState.ReadData;
UpdateFileTransferState();
SendFileDataReadRequest();
}
}
}
else
{
file_operation_info.Callback(packet);
}
}
private static void InvokeProgressEvent(uint currentFileSlicesCount, uint currentFileSlice, FileTransferState state)
{
if (state == FileTransferState.Finished)
{
throw new InvalidOperationException();
}
FileTransferProgressEventArgs ea = null;
if (!isQueue)
{
ea = new FileTransferProgressEventArgs {
CurrentPart = currentFileSlice + 1, Total = currentFileSlicesCount, State = FileTransferState.DataTransfer, Guid = requestGuid, SenderName = senderName, TotalFiles = filesCount
};
System.Diagnostics.Debug.WriteLine(ea.CurrentPart + " / " + ea.Total);
}
else if (state == FileTransferState.QueueList)
{
ea = new FileTransferProgressEventArgs {
CurrentPart = 0, Total = 0, State = FileTransferState.QueueList, Guid = requestGuid, SenderName = senderName, TotalFiles = filesCount
};
System.Diagnostics.Debug.WriteLine("Downloading queue data...");
}
else
{
ea = new FileTransferProgressEventArgs {
CurrentPart = (ulong)(queueSlicesFinished + currentFileSlice + 1), Total = (ulong)queueTotalSlices, State = FileTransferState.QueueList, Guid = requestGuid, SenderName = senderName, TotalFiles = filesCount
};
System.Diagnostics.Debug.WriteLine(ea.CurrentPart + " / " + ea.Total);
}
FileTransferProgress?.Invoke(ea);
}
public TransferErrorEventArgs(IEnumerable <ITransferItem> items, string fromUri, FileTransferState itemsState, bool isLocal)
: base(items, fromUri)
{
this.ItemsState = itemsState;
this.IsLocal = isLocal;
}
public StateChangeEventArg(FileTransferState arg)
{
FileTransferState = arg;
}
private void OnEndFileTransfer() {
_fileTransferState = FileTransferState.None;
// Returns reconstructed received file data to event listeners
if (ReceiveFileFinished != null) {
byte[] data = _fileMemoryStream.ToArray();
ReceiveFileFinished(data);
}
}
private void ProcessFileChunk(byte[] data) {
// Check if we can receive a chunk
if (_fileTransferState != FileTransferState.Receiving) {
_fileTransferState = FileTransferState.None;
Debug.LogError("Received a file chunk when not in receival mode");
return;
}
// Notify event listeners about new incoming chunk
if (ReceiveFileChunk != null)
ReceiveFileChunk(data.Length);
// Save chunk data
_fileMemoryStream.Write(data, 0, data.Length);
}
private void FileControlReceivedHandler(object sender, ToxEventArgs.FileControlEventArgs e)
{
if (IsPlaceholder || !IsThisTransfer(e))
return;
switch (e.Control)
{
case ToxFileControl.Cancel:
FileTransferResumer.Instance.RemoveTransfer(_friendNumber, _fileNumber);
State = FileTransferState.Cancelled;
return;
case ToxFileControl.Pause:
TryPauseTransfer();
return;
case ToxFileControl.Resume:
TryResumeTransfer();
return;
}
}
/// <summary>
/// Processes received file data block
/// </summary>
private void ProcessFileDataReadResponse()
{
byte[] packet;
byte packet_length;
byte interface_index;
DateTime packet_timestamp;
PacketFileDataReadResponseHeader packet_header;
int data_offset;
int data_length;
string file_operation_id;
PendingFileOperationInfo file_operation_info;
if (CommunicationManager.Default.ReceiverQueue.PopBegin(out packet, out packet_length, out interface_index, out packet_timestamp))
{
// get packet header
packet_header = (PacketFileDataReadResponseHeader)RawBinarySerialization.DeserializeObject(packet, typeof(PacketFileDataReadResponseHeader));
CommunicationManager.Default.PacketLogWrite("R", packet_header);
// check pending file operation
file_operation_id = packet_header.FileOperationID;
if (m_pending_file_operations.ContainsKey(file_operation_id))
{
file_operation_info = m_pending_file_operations[file_operation_id];
// finish file operation
FileOperationEnd(packet_header);
if (file_operation_info.Packet.PacketType == PacketType.FileDataReadRequest)
{
// determine file data block position and length within the packet
data_offset = Marshal.SizeOf(typeof(PacketFileDataReadResponseHeader));
data_length = packet_header.PacketLength - PacketConstants.PacketCRCLength - Marshal.SizeOf(typeof(PacketFileDataReadResponseHeader));
// if no callback if defined, this is regular system file operation
if (file_operation_info.Callback == null)
{
m_file_transfer_current_file.Write(packet, data_offset, data_length);
m_file_transfer_current_position += (uint)data_length;
UpdateFileTransferState();
if (m_file_transfer_current_position < m_file_transfer_current_size)
{
SendFileDataReadRequest();
}
else
{
m_file_transfer_current_file.Close();
m_file_transfer_state = FileTransferState.Idle;
CallFileTransferFinishedCallback(new FileTransferResultInfo(FileTransferResult.Success, m_file_transfer_current_id, m_file_transfer_current_file.FullFilePath));
m_file_transfer_current_file.Dispose();
m_file_transfer_current_file = null;
}
}
else
{
// prepare deserialized packet for further file data processing
PacketFileDataReadResponse response = new PacketFileDataReadResponse(packet_header);
response.SetData(packet, data_offset, data_length);
file_operation_info.Callback(response);
}
}
}
// close packet processing
CommunicationManager.Default.ReceiverQueue.PopEnd();
}
}
private void TryPauseTransfer()
{
if (State != FileTransferState.Uploading && State != FileTransferState.Downloading)
return;
State = FileTransferState.PausedByFriend;
}
/// <summary>
/// Handles timeout condition
/// </summary>
public void FileOperationTimeOutHandler()
{
DateTime current_time = DateTime.Now;
List <string> file_operations_timeout = new List <string>();
lock (m_pending_file_operations)
{
// check all pending file operation
foreach (KeyValuePair <string, PendingFileOperationInfo> pending_operation in m_pending_file_operations)
{
if ((current_time - pending_operation.Value.SendTime).TotalMilliseconds > FileOperationTimeout)
{
if (pending_operation.Value.RetryCount > FileOperationMaxRetryCount)
{
// operation failed
file_operations_timeout.Add(pending_operation.Key);
}
else
{
// resend oroginal packet again
pending_operation.Value.RetryCount++;
pending_operation.Value.SendTime = current_time;
if (pending_operation.Value.Data == null)
{
CommunicationManager.Default.SendPacket(pending_operation.Value.Packet);
CommunicationManager.Default.PacketLogWrite("S+", pending_operation.Value.Packet);
}
else
{
CommunicationManager.Default.SendPacket(pending_operation.Value.Packet, pending_operation.Value.Data);
CommunicationManager.Default.PacketLogWrite("S+", pending_operation.Value.Packet);
}
}
}
}
}
// handle failed operations
foreach (string operation_id in file_operations_timeout)
{
PendingFileOperationInfo file_operation_info = m_pending_file_operations[operation_id];
// remove operation from pending list
lock (m_pending_file_operations)
{
m_pending_file_operations.Remove(operation_id);
}
// if no callback if defined, this is regular system file operation
if (file_operation_info.Callback == null)
{
// file transfer state: idle
m_file_transfer_state = FileTransferState.Idle;
// call file transfer callback with error
CallFileTransferFinishedCallback(new FileTransferResultInfo(FileTransferResult.Error));
}
else
{
file_operation_info.Callback(null);
}
}
}
private void OnStartFileTransfer(int fileSize) {
_fileTransferState = FileTransferState.Receiving;
// Notify event listener about start of file receival
if (ReceiveFileStarted != null)
ReceiveFileStarted(fileSize);
// Allocate a temporary memory stream for incoming file
_fileMemoryStream = new MemoryStream(fileSize);
}