public static bool receiveAcceptFile(Friend friend, string uid)
{
FileTransfer transfer = TransferManager.getOutgoingTransfer(uid);
if (transfer == null)
{
return(false);
}
// Send first packet
return(TransferManager.sendFileData(friend, uid, 0));
}
public static bool sendFileData(Friend friend, string uid, ulong packet_number)
{
FileTransfer transfer = TransferManager.getOutgoingTransfer(uid);
if (transfer == null)
{
return(false);
}
using (MemoryStream m = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(m))
{
if (uid != null)
{
writer.Write(uid);
}
writer.Write(packet_number);
Logging.info("Fetching packet #{0}", packet_number);
byte[] data = transfer.getPacketData(packet_number);
// Write the data
if (data != null)
{
writer.Write(data.Length);
writer.Write(data);
}
else
{
writer.Write(0);
}
}
SpixiMessage spixi_message = new SpixiMessage(Guid.NewGuid().ToByteArray(), SpixiMessageCode.fileData, m.ToArray());
StreamMessage message = new StreamMessage();
message.type = StreamMessageCode.data;
message.recipient = friend.walletAddress;
message.sender = Node.walletStorage.getPrimaryAddress();
message.transaction = new byte[1];
message.sigdata = new byte[1];
message.data = spixi_message.getBytes();
StreamProcessor.sendMessage(friend, message);
}
return(true);
}
public static void handlefileData(byte[] sender, SpixiMessage data)
{
Friend friend = FriendList.getFriend(sender);
if (friend != null)
{
TransferManager.receiveFileData(data.data, sender);
}
else
{
Logging.error("Received file data from an unknown friend.");
}
}
// Called when receiving file headers from the message recipient
public static void handleFileHeader(byte[] sender, SpixiMessage data)
{
Friend friend = FriendList.getFriend(sender);
if (friend != null)
{
FileTransfer transfer = TransferManager.prepareIncomingFileTransfer(data.data, sender);
string message_data = string.Format("{0}:{1}", transfer.uid, transfer.fileName);
FriendList.addMessageWithType(data.id, FriendMessageType.fileHeader, sender, message_data);
}
else
{
Logging.error("Received File Header from an unknown friend.");
}
}
public static void requestFileData(byte[] sender, string uid, ulong packet_number)
{
Logging.info("Requesting File Data, packet #{0}", packet_number);
Friend friend = FriendList.getFriend(sender);
if (friend == null)
{
return;
}
using (MemoryStream m = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(m))
{
if (uid != null)
{
writer.Write(uid);
}
writer.Write(packet_number);
}
SpixiMessage spixi_message = new SpixiMessage(Guid.NewGuid().ToByteArray(), SpixiMessageCode.requestFileData, m.ToArray());
StreamMessage message = new StreamMessage();
message.type = StreamMessageCode.data;
message.recipient = friend.walletAddress;
message.sender = Node.walletStorage.getPrimaryAddress();
message.transaction = new byte[1];
message.sigdata = new byte[1];
message.data = spixi_message.getBytes();
StreamProcessor.sendMessage(friend, message);
if (friend.chat_page != null)
{
FileTransfer transfer = TransferManager.getIncomingTransfer(uid);
if (transfer == null)
{
return;
}
ulong totalPackets = transfer.fileSize / (ulong)Config.packetDataSize;
ulong fp = 100 / totalPackets * (packet_number - 1);
friend.chat_page.updateFile(uid, fp.ToString(), false);
}
}
}
public async System.Threading.Tasks.Task onSendFile()
{
try
{
FileData fileData = await CrossFilePicker.Current.PickFile();
if (fileData == null)
{
return; // User canceled file picking
}
string fileName = fileData.FileName;
string filePath = fileData.FilePath;
FileTransfer transfer = TransferManager.prepareFileTransfer(fileName, fileData.GetStream(), filePath);
Logging.info("File Transfer uid: " + transfer.uid);
SpixiMessage spixi_message = new SpixiMessage(SpixiMessageCode.fileHeader, transfer.getBytes());
StreamMessage message = new StreamMessage();
message.type = StreamMessageCode.data;
message.recipient = friend.walletAddress;
message.sender = Node.walletStorage.getPrimaryAddress();
message.transaction = new byte[1];
message.sigdata = new byte[1];
message.data = spixi_message.getBytes();
StreamProcessor.sendMessage(friend, message);
string message_data = string.Format("{0}:{1}", transfer.uid, transfer.fileName);
// store the message and display it
FriendMessage friend_message = FriendList.addMessageWithType(message.id, FriendMessageType.fileHeader, friend.walletAddress, message_data, true);
friend_message.transferId = transfer.uid;
friend_message.filePath = transfer.filePath;
Node.localStorage.writeMessages(friend.walletAddress, friend.messages);
}
catch (Exception ex)
{
Logging.error("Exception choosing file: " + ex.ToString());
}
}
public void onDeleteDownloads()
{
try
{
TransferManager.resetIncomingTransfers();
int file_count = 0;
foreach (var file in Directory.EnumerateFiles(Path.Combine(Config.spixiUserFolder, "Downloads")))
{
File.Delete(file);
file_count++;
}
displaySpixiAlert(SpixiLocalization._SL("settings-deletedd-title"), string.Format(SpixiLocalization._SL("settings-deletedd-text"), file_count), SpixiLocalization._SL("global-dialog-ok"));
}
catch (Exception e)
{
Logging.error("Exception while deleting downloads: " + e);
displaySpixiAlert(SpixiLocalization._SL("settings-deleted-error-title"), SpixiLocalization._SL("settings-deleted-error-text"), SpixiLocalization._SL("global-dialog-ok"));
}
}
public void onDeleteDownloads()
{
try
{
TransferManager.resetIncomingTransfers();
int file_count = 0;
foreach (var file in Directory.EnumerateFiles(Path.Combine(Config.spixiUserFolder, "Downloads")))
{
File.Delete(file);
file_count++;
}
displaySpixiAlert("Done", "Deleted " + file_count + " downloaded files.", "OK");
}
catch (Exception e)
{
Logging.error("Exception while deleting downloads: " + e);
displaySpixiAlert("Error", "An unknown error has occured.", "OK");
}
}
public static void completeFileTransfer(byte[] sender, string uid)
{
Friend friend = FriendList.getFriend(sender);
if (friend == null)
{
return;
}
FileTransfer transfer = TransferManager.getIncomingTransfer(uid);
if (transfer == null)
{
transfer = TransferManager.getOutgoingTransfer(uid);
if (transfer == null)
{
return;
}
}
transfer.fileStream.Dispose();
transfer.completed = true;
removePacketsForFileTransfer(uid);
FriendMessage fm = friend.messages.Find(x => x.transferId == uid);
fm.completed = true;
fm.filePath = transfer.filePath;
Node.localStorage.writeMessages(friend.walletAddress, friend.messages);
if (friend.chat_page != null)
{
friend.chat_page.updateFile(uid, "100", true);
}
}
private void onNavigating(object sender, WebNavigatingEventArgs e)
{
string current_url = HttpUtility.UrlDecode(e.Url);
e.Cancel = true;
if (current_url.Equals("ixian:onload", StringComparison.Ordinal))
{
onLoad();
}
else if (current_url.Equals("ixian:back", StringComparison.Ordinal))
{
friend.chat_page = null;
Navigation.PopAsync(Config.defaultXamarinAnimations);
}
else if (current_url.Equals("ixian:request", StringComparison.Ordinal))
{
Navigation.PushAsync(new WalletReceivePage(friend), Config.defaultXamarinAnimations);
}
else if (current_url.Equals("ixian:details", StringComparison.Ordinal))
{
Navigation.PushAsync(new ContactDetails(friend, true), Config.defaultXamarinAnimations);
}
else if (current_url.Equals("ixian:send", StringComparison.Ordinal))
{
Navigation.PushAsync(new WalletSendPage(friend.walletAddress), Config.defaultXamarinAnimations);
}
else if (current_url.Equals("ixian:accept", StringComparison.Ordinal))
{
onAcceptFriendRequest();
}
else if (current_url.Equals("ixian:call", StringComparison.Ordinal))
{
displaySpixiAlert("Voice Call", "Coming soon.\nCheck regularly for new version on www.spixi.io", "Ok");
}
else if (current_url.Equals("ixian:sendfile", StringComparison.Ordinal))
{
//displaySpixiAlert("Send File", "\nCheck regularly for new version on www.spixi.io", "Ok");
onSendFile();
}
else if (current_url.Contains("ixian:acceptfile:"))
{
string[] split = current_url.Split(new string[] { "ixian:acceptfile:" }, StringSplitOptions.None);
string id = split[1];
onAcceptFile(id);
}
else if (current_url.Contains("ixian:openfile:"))
{
// TODO: save the file path for later instances
string[] split = current_url.Split(new string[] { "ixian:openfile:" }, StringSplitOptions.None);
string id = split[1];
FileTransfer transfer = TransferManager.getIncomingTransfer(id);
if (transfer == null)
{
transfer = TransferManager.getOutgoingTransfer(id);
}
if (transfer == null)
{
displaySpixiAlert("Expired", "File link has expired.", "Ok");
return;
}
// Open file in default app. May not work, check https://forums.xamarin.com/discussion/103042/how-to-open-pdf-or-txt-file-in-default-app-on-xamarin-forms
Device.OpenUri(new Uri(transfer.filePath));
}
else if (current_url.Contains("ixian:chat:"))
{
string[] split = current_url.Split(new string[] { "ixian:chat:" }, StringSplitOptions.None);
string msg = split[1];
onSend(msg);
}
else if (current_url.Contains("ixian:viewPayment:"))
{
string[] split = current_url.Split(new string[] { "ixian:viewPayment:" }, StringSplitOptions.None);
string id = split[1];
onViewPayment(id);
}
else
{
// Otherwise it's just normal navigation
e.Cancel = false;
return;
}
e.Cancel = true;
}
public void onAcceptFile(string uid)
{
//displaySpixiAlert("File", uid, "Ok");
TransferManager.acceptFile(friend, uid);
updateFile(uid, "0", false);
}
public async Task onSendFile()
{
// Show file picker and send the file
try
{
Stream stream = null;
string fileName = null;
string filePath = null;
// Special case for iOS platform
if (Device.RuntimePlatform == Device.iOS)
{
var picker_service = DependencyService.Get <IPicturePicker>();
SpixiImageData spixi_img_data = await picker_service.PickImageAsync();
stream = spixi_img_data.stream;
if (stream == null)
{
return;
}
fileName = spixi_img_data.name;
filePath = spixi_img_data.path;
}
else
{
FileData fileData = await CrossFilePicker.Current.PickFile();
if (fileData == null)
{
return; // User canceled file picking
}
stream = fileData.GetStream();
fileName = fileData.FileName;
filePath = fileData.FilePath;
}
FileTransfer transfer = TransferManager.prepareFileTransfer(fileName, stream, filePath);
Logging.info("File Transfer uid: " + transfer.uid);
SpixiMessage spixi_message = new SpixiMessage(SpixiMessageCode.fileHeader, transfer.getBytes());
StreamMessage message = new StreamMessage();
message.type = StreamMessageCode.data;
message.recipient = friend.walletAddress;
message.sender = Node.walletStorage.getPrimaryAddress();
message.transaction = new byte[1];
message.sigdata = new byte[1];
message.data = spixi_message.getBytes();
StreamProcessor.sendMessage(friend, message);
string message_data = string.Format("{0}:{1}", transfer.uid, transfer.fileName);
// store the message and display it
FriendMessage friend_message = FriendList.addMessageWithType(message.id, FriendMessageType.fileHeader, friend.walletAddress, message_data, true);
friend_message.transferId = transfer.uid;
friend_message.filePath = transfer.filePath;
Node.localStorage.writeMessages(friend.walletAddress, friend.messages);
}
catch (Exception ex)
{
Logging.error("Exception choosing file: " + ex.ToString());
}
}
public static bool receiveFileData(byte[] data, byte[] sender)
{
Logging.info("Received File Data");
byte[] file_data = null;
try
{
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
string uid = reader.ReadString();
ulong packet_number = reader.ReadUInt64();
FilePacket packet = new FilePacket(uid, packet_number);
if (checkPacketLog(packet))
{
return(false);
}
int data_length = reader.ReadInt32();
if (data_length > 0)
{
file_data = reader.ReadBytes(data_length);
}
Logging.info("File Uid: {0} Packet #{1}", uid, packet_number);
FileTransfer transfer = TransferManager.getIncomingTransfer(uid);
if (transfer == null)
{
return(false);
}
// Check if the transfer is already completed
if (transfer.completed)
{
return(false);
}
// Check if this is the next packet to process
if (transfer.lastPacket != packet_number)
{
return(false);
}
incomingPacketsLog.Add(packet);
transfer.fileStream.Seek(Config.packetDataSize * (int)packet_number, SeekOrigin.Begin);
transfer.fileStream.Write(file_data, 0, file_data.Length);
transfer.updateActivity(packet_number + 1);
ulong new_packet_number = packet_number + 1;
if (new_packet_number * (ulong)Config.packetDataSize > transfer.fileSize + (ulong)Config.packetDataSize)
{
completeFileTransfer(sender, uid);
sendFileTransferCompleted(sender, uid);
return(true);
}
requestFileData(sender, uid, new_packet_number);
}
}
}
catch (Exception e)
{
Logging.error("Exception occured while receiving file data from bytes: " + e);
}
return(true);
}
public static bool sendFileData(Friend friend, string uid, ulong packet_number)
{
FileTransfer transfer = TransferManager.getOutgoingTransfer(uid);
if (transfer == null)
{
return(false);
}
using (MemoryStream m = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(m))
{
writer.Write(uid);
writer.Write(packet_number);
Logging.info("Sending file packet #{0}", packet_number);
byte[] data = transfer.getPacketData(packet_number);
// Write the data
if (data != null)
{
writer.Write(data.Length);
writer.Write(data);
}
else
{
writer.Write(0);
}
}
SpixiMessage spixi_message = new SpixiMessage(SpixiMessageCode.fileData, m.ToArray());
StreamMessage message = new StreamMessage();
message.type = StreamMessageCode.data;
message.recipient = friend.walletAddress;
message.sender = Node.walletStorage.getPrimaryAddress();
message.transaction = new byte[1];
message.sigdata = new byte[1];
message.data = spixi_message.getBytes();
StreamProcessor.sendMessage(friend, message, false, false, false);
}
if (friend.chat_page != null)
{
ulong totalPackets = transfer.fileSize / (ulong)Config.packetDataSize;
ulong fp = 0;
bool complete = false;
if (totalPackets == packet_number)
{
fp = 100;
complete = true;
}
else
{
fp = 100 / totalPackets * packet_number;
}
friend.chat_page.updateFile(uid, fp.ToString(), complete);
}
return(true);
}
public static void completeFileTransfer(byte[] sender, string uid)
{
Friend friend = FriendList.getFriend(sender);
if (friend == null)
{
return;
}
bool incoming = true;
FileTransfer transfer = TransferManager.getIncomingTransfer(uid);
if (transfer == null)
{
incoming = false;
transfer = TransferManager.getOutgoingTransfer(uid);
if (transfer == null)
{
return;
}
}
transfer.fileStream.Dispose();
if (incoming && transfer.fileName != null && transfer.fileName != "")
{
string final_file_path = Path.Combine(downloadsPath, transfer.fileName);
int instance_num = 0;
while (File.Exists(final_file_path))
{
instance_num++;
final_file_path = Path.Combine(downloadsPath, Path.GetFileNameWithoutExtension(transfer.fileName) + "-" + instance_num.ToString() + Path.GetExtension(transfer.fileName));
}
File.Move(transfer.filePath, final_file_path);
transfer.filePath = final_file_path;
}
transfer.completed = true;
removePacketsForFileTransfer(uid);
FriendMessage fm = friend.getMessages(transfer.channel).Find(x => x.transferId == uid);
fm.completed = true;
fm.filePath = transfer.filePath;
Node.localStorage.requestWriteMessages(friend.walletAddress, transfer.channel);
if (incoming)
{
lock (incomingTransfers)
{
incomingTransfers.Remove(transfer);
}
}
else
{
lock (outgoingTransfers)
{
outgoingTransfers.Remove(transfer);
}
}
if (friend.chat_page != null)
{
friend.chat_page.updateFile(uid, "100", true);
}
}
