private void onNavigating(object sender, WebNavigatingEventArgs e)
{
string current_url = HttpUtility.UrlDecode(e.Url);
if (onNavigatingGlobal(current_url))
{
e.Cancel = true;
return;
}
if (current_url.Equals("ixian:onload", StringComparison.Ordinal))
{
onLoad();
}
else if (current_url.Equals("ixian:back", StringComparison.Ordinal))
{
Navigation.PopAsync(Config.defaultXamarinAnimations);
}
else if (current_url.Equals("ixian:error", StringComparison.Ordinal))
{
displaySpixiAlert(SpixiLocalization._SL("settings-backup-invalidpassword-title"), SpixiLocalization._SL("settings-backup-invalidpassword-text"), SpixiLocalization._SL("global-dialog-ok"));
}
else if (current_url.Equals("ixian:backup", StringComparison.Ordinal))
{
onBackup();
}
else
{
// Otherwise it's just normal navigation
e.Cancel = false;
return;
}
e.Cancel = true;
}
private void proceed(string pass)
{
// TODO: encrypt the password
Application.Current.Properties["walletpass"] = pass;
Application.Current.SavePropertiesAsync(); // Force-save properties for compatibility with WPF
bool wallet_decrypted = Node.loadWallet();
if (wallet_decrypted == false)
{
displaySpixiAlert(SpixiLocalization._SL("intro-retry-invalidpassword-title"), SpixiLocalization._SL("intro-retry-invalidpassword-text"), SpixiLocalization._SL("global-dialog-ok"));
// If too many wrong attempts, throw the user to the launch screen, allowing creation or restoration of wallet
attempts++;
if (attempts > Config.encryptionRetryPasswordAttempts)
{
Navigation.PushAsync(new LaunchPage(), Config.defaultXamarinAnimations);
Navigation.RemovePage(this);
}
// Remove overlay
Utils.sendUiCommand(webView, "removeLoadingOverlay");
return;
}
Navigation.PushAsync(HomePage.Instance(true), Config.defaultXamarinAnimations);
Navigation.RemovePage(this);
}
public Node()
{
#if DEBUG
Logging.warn("Testing language files");
SpixiLocalization.testLanguageFiles("en-us");
#endif
Logging.info("Initing node constructor");
Instance = this;
IxianHandler.init(Config.version, this, Config.networkType);
// Prepare the wallet
walletStorage = new WalletStorage(Path.Combine(Config.spixiUserFolder, Config.walletFile));
PeerStorage.init(Config.spixiUserFolder);
// Init TIV
tiv = new TransactionInclusion();
Logging.info("Initing local storage");
// Prepare the local storage
localStorage = new SPIXI.Storage.LocalStorage(Config.spixiUserFolder);
customAppManager = new CustomAppManager(Config.spixiUserFolder);
FriendList.init(Config.spixiUserFolder);
Logging.info("Node init done");
}
private void onNavigating(object sender, WebNavigatingEventArgs e)
{
string current_url = HttpUtility.UrlDecode(e.Url);
if (current_url.Equals("ixian:create", StringComparison.Ordinal))
{
Navigation.PushAsync(new LaunchCreatePage(), Config.defaultXamarinAnimations);
}
else if (current_url.Equals("ixian:restore", StringComparison.Ordinal))
{
Navigation.PushAsync(new LaunchRestorePage(), Config.defaultXamarinAnimations);
}
else if (current_url.StartsWith("ixian:language:", StringComparison.Ordinal))
{
string lang = current_url.Substring("ixian:language:".Length);
if (SpixiLocalization.loadLanguage(lang))
{
Application.Current.Properties["language"] = lang;
Application.Current.SavePropertiesAsync(); // Force-save properties for compatibility with WPF
}
loadPage(webView, "intro.html");
}
else
{
// Otherwise it's just normal navigation
e.Cancel = false;
return;
}
e.Cancel = true;
}
// Retrieve the transaction from local cache storage
private void checkTransaction()
{
string confirmed_text = SpixiLocalization._SL("wallet-sent-confirmed");
Transaction ctransaction = TransactionCache.getTransaction(transaction.id);
if (ctransaction == null || ctransaction.applied == 0)
{
ctransaction = transaction;
confirmed_text = SpixiLocalization._SL("wallet-sent-unconfirmed");
}
IxiNumber amount = ctransaction.amount;
// Convert unix timestamp
string time = Utils.UnixTimeStampToString(Convert.ToDouble(ctransaction.timeStamp));
byte[] addr = new Address(ctransaction.pubKey).address;
if (addr.SequenceEqual(IxianHandler.getWalletStorage().getPrimaryAddress()))
{
// this is a sent payment
foreach (var entry in ctransaction.toList)
{
//Utils.sendUiCommand(webView, "addSender", Base58Check.Base58CheckEncoding.EncodePlain(entry.Key) + ": " + entry.Value.ToString(), time);
Utils.sendUiCommand(webView, "addSender", Encoding.ASCII.GetString(ctransaction.data) + ": " + entry.Value.ToString(), time);
}
}
Utils.sendUiCommand(webView, "setData", amount.ToString(), ctransaction.fee.ToString(),
time, confirmed_text, (ctransaction.fee / ctransaction.amount).ToString() + "%", Transaction.txIdV8ToLegacy(transaction.id));
return;
}
private void onNavigating(object sender, WebNavigatingEventArgs e)
{
string current_url = HttpUtility.UrlDecode(e.Url);
if (current_url.Equals("ixian:back", StringComparison.Ordinal))
{
Navigation.PopAsync(Config.defaultXamarinAnimations);
}
else if (current_url.Equals("ixian:selectfile", StringComparison.Ordinal))
{
onSelectFile();
}
else if (current_url.Contains("ixian:restore:"))
{
string[] split = current_url.Split(new string[] { "ixian:restore:" }, StringSplitOptions.None);
if (split.Count() < 1)
{
e.Cancel = true;
Utils.sendUiCommand(webView, "removeLoadingOverlay");
displaySpixiAlert(SpixiLocalization._SL("intro-restore-file-invalidpassword-title"), SpixiLocalization._SL("intro-restore-file-invalidpassword-text"), SpixiLocalization._SL("global-dialog-ok"));
return;
}
string password = split[1]; // Todo: secure this
onRestore(password);
}
else
{
// Otherwise it's just normal navigation
e.Cancel = false;
return;
}
e.Cancel = true;
}
public void onDeleteWallet(object sender, EventArgs e)
{
if (Node.walletStorage.deleteWallet())
{
Node.walletStorage = new WalletStorage(Path.Combine(Config.spixiUserFolder, Config.walletFile));
// Also delete the account
onDeleteAccount();
// Stop network activity
Node.stop();
Application.Current.Properties.Remove("onboardingComplete");
Application.Current.SavePropertiesAsync(); // Force-save properties for compatibility with WPF
SpixiLocalization.addCustomString("OnboardingComplete", "false");
Node.localStorage.deleteTransactionCacheFile();
TransactionCache.clearAllTransactions();
Node.tiv.clearCache();
// Show the launch page
Navigation.PushAsync(new LaunchPage(), Config.defaultXamarinAnimations);
// Remove the settings page
Navigation.RemovePage(this);
// Todo: also remove the parent page without causing memory leaks
}
else
{
displaySpixiAlert(SpixiLocalization._SL("settings-deletew-error-title"), SpixiLocalization._SL("settings-deletew-error-text"), SpixiLocalization._SL("global-dialog-ok"));
}
}
//
// This method is invoked when the application has loaded and is ready to run. In this
// method you should instantiate the window, load the UI into it and then make the window
// visible.
//
// You have 17 seconds to return from this method, or iOS will terminate your application.
//
public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
if (UIDevice.CurrentDevice.CheckSystemVersion(10, 0))
{
// Ask the user for permission to get notifications on iOS 10.0+
UNUserNotificationCenter.Current.RequestAuthorization(
UNAuthorizationOptions.Alert | UNAuthorizationOptions.Badge | UNAuthorizationOptions.Sound,
(approved, error) => { });
}
else if (UIDevice.CurrentDevice.CheckSystemVersion(8, 0))
{
// Ask the user for permission to get notifications on iOS 8.0+
var settings = UIUserNotificationSettings.GetSettingsForTypes(
UIUserNotificationType.Alert | UIUserNotificationType.Badge | UIUserNotificationType.Sound,
new NSSet());
UIApplication.SharedApplication.RegisterUserNotificationSettings(settings);
}
UIApplication.SharedApplication.SetMinimumBackgroundFetchInterval(UIApplication.BackgroundFetchIntervalMinimum);
global::Xamarin.Forms.Forms.Init();
global::ZXing.Net.Mobile.Forms.iOS.Platform.Init();
prepareStorage();
NSNotificationCenter.DefaultCenter.AddObserver(MPMusicPlayerController.VolumeDidChangeNotification, onVolumeChanged);
SpixiLocalization.addCustomString("Platform", "Xamarin-iOS");
LoadApplication(App.Instance());
prepareBackgroundService();
return(base.FinishedLaunching(app, options));
}
public void loadTransactions()
{
// Check if there are any changes
if (lastTransactionChange == TransactionCache.lastChange)
{
return;
}
lastTransactionChange = TransactionCache.lastChange;
Utils.sendUiCommand(webView, "clearPaymentActivity");
for (int i = TransactionCache.unconfirmedTransactions.Count - 1; i >= 0; i--)
{
Transaction utransaction = TransactionCache.unconfirmedTransactions[i];
string tx_type = SpixiLocalization._SL("index-excerpt-payment-received");
IxiNumber amount = utransaction.amount;
if (Node.walletStorage.isMyAddress((new Address(utransaction.pubKey).address)))
{
tx_type = SpixiLocalization._SL("index-excerpt-payment-sent");
}
else
{
amount = calculateReceivedAmount(utransaction);
}
string time = Utils.UnixTimeStampToString(Convert.ToDouble(utransaction.timeStamp));
Utils.sendUiCommand(webView, "addPaymentActivity", Transaction.txIdV8ToLegacy(utransaction.id), tx_type, time, amount.ToString(), "false");
}
int max_tx_count = 0;
if (TransactionCache.transactions.Count > 50)
{
max_tx_count = TransactionCache.transactions.Count - 50;
}
for (int i = TransactionCache.transactions.Count - 1; i >= max_tx_count; i--)
{
Transaction transaction = TransactionCache.transactions[i];
string tx_type = SpixiLocalization._SL("index-excerpt-payment-received");
IxiNumber amount = transaction.amount;
if (Node.walletStorage.isMyAddress((new Address(transaction.pubKey).address)))
{
tx_type = SpixiLocalization._SL("index-excerpt-payment-sent");
}
else
{
amount = calculateReceivedAmount(transaction);
}
string time = Utils.UnixTimeStampToString(Convert.ToDouble(transaction.timeStamp));
string confirmed = "true";
if (transaction.applied == 0)
{
confirmed = "error";
}
Utils.sendUiCommand(webView, "addPaymentActivity", Transaction.txIdV8ToLegacy(transaction.id), tx_type, time, amount.ToString(), confirmed);
}
}
private void onRemoveHistory()
{
// Remove history file
if (friend.deleteHistory())
{
displaySpixiAlert(SpixiLocalization._SL("contact-details-deletedhistory-title"), SpixiLocalization._SL("contact-details-deletedhistory-text"), SpixiLocalization._SL("global-dialog-ok"));
}
}
public void loadTransactions()
{
Utils.sendUiCommand(webView, "clearRecentActivity");
lock (TransactionCache.unconfirmedTransactions)
{
foreach (Transaction utransaction in TransactionCache.unconfirmedTransactions)
{
byte[] from_address = new Address(utransaction.pubKey).address;
// Filter out unrelated transactions
if (from_address.SequenceEqual(friend.walletAddress) == false)
{
if (utransaction.toList.ContainsKey(friend.walletAddress) == false)
{
continue;
}
}
string tx_type = SpixiLocalization._SL("global-received");
if (from_address.SequenceEqual(IxianHandler.getWalletStorage().getPrimaryAddress()))
{
tx_type = SpixiLocalization._SL("global-sent");
}
string time = Utils.UnixTimeStampToString(Convert.ToDouble(utransaction.timeStamp));
Utils.sendUiCommand(webView, "addPaymentActivity", Transaction.txIdV8ToLegacy(utransaction.id), tx_type, time, utransaction.amount.ToString(), "false");
}
for (int i = TransactionCache.transactions.Count - 1; i >= 0; i--)
{
Transaction transaction = TransactionCache.transactions[i];
byte[] from_address = new Address(transaction.pubKey).address;
// Filter out unrelated transactions
if (from_address.SequenceEqual(friend.walletAddress) == false)
{
if (transaction.toList.ContainsKey(friend.walletAddress) == false)
{
continue;
}
}
string tx_type = SpixiLocalization._SL("global-received");
if (from_address.SequenceEqual(IxianHandler.getWalletStorage().getPrimaryAddress()))
{
tx_type = SpixiLocalization._SL("global-sent");
}
string time = Utils.UnixTimeStampToString(Convert.ToDouble(transaction.timeStamp));
string confirmed = "true";
if (transaction.applied == 0)
{
confirmed = "error";
}
Utils.sendUiCommand(webView, "addPaymentActivity", Transaction.txIdV8ToLegacy(transaction.id), tx_type, time, transaction.amount.ToString(), confirmed);
}
}
}
public void onCreateAccount(string nick, string pass)
{
// Generate the account on a different thread
new Thread(() =>
{
// Aquire the wake lock
bool wake_lock_sd = DependencyService.Get <IPowerManager>().AquireLock("screenDim");
bool wake_lock_p = DependencyService.Get <IPowerManager>().AquireLock("partial");
if (Node.generateWallet(pass))
{
Node.generatedNewWallet = true;
Node.start();
Node.localStorage.nickname = nick;
Node.localStorage.writeAccountFile();
// TODO: encrypt the password
Application.Current.Properties["walletpass"] = pass;
Application.Current.SavePropertiesAsync(); // Force-save properties for compatibility with WPF
// Release the wake lock
if (wake_lock_sd)
{
DependencyService.Get <IPowerManager>().ReleaseLock("screenDim");
}
if (wake_lock_p)
{
DependencyService.Get <IPowerManager>().ReleaseLock("partial");
}
Device.BeginInvokeOnMainThread(() => {
Navigation.PushAsync(HomePage.Instance(true), Config.defaultXamarinAnimations);
Navigation.RemovePage(this);
});
}
else
{
// Release the wake lock
if (wake_lock_sd)
{
DependencyService.Get <IPowerManager>().ReleaseLock("screenDim");
}
if (wake_lock_p)
{
DependencyService.Get <IPowerManager>().ReleaseLock("partial");
}
Device.BeginInvokeOnMainThread(() => {
displaySpixiAlert(SpixiLocalization._SL("intro-new-walleterror-title"), SpixiLocalization._SL("intro-new-walleterror-text"), SpixiLocalization._SL("global-dialog-ok"));
});
return;
}
}).Start();
}
private void resetLanguage()
{
string lang = "en-us";
if (Application.Current.Properties.ContainsKey("language"))
{
lang = Application.Current.Properties["language"] as string;
}
SpixiLocalization.loadLanguage(lang);
}
public void onDeleteAccount()
{
Node.localStorage.deleteAllAvatars();
Node.localStorage.deleteAccountFile();
Node.localStorage.deleteAllDownloads();
StreamProcessor.deletePendingMessages();
FriendList.deleteEntireHistory();
FriendList.clear();
displaySpixiAlert(SpixiLocalization._SL("settings-deleteda-title"), SpixiLocalization._SL("settings-deleteda-text"), SpixiLocalization._SL("global-dialog-ok"));
}
private void onUninstall()
{
if (Node.customAppManager.remove(appId))
{
displaySpixiAlert(SpixiLocalization._SL("app-details-dialog-title"), SpixiLocalization._SL("app-details-dialog-removed-text"), SpixiLocalization._SL("global-dialog-ok"));
}
else
{
displaySpixiAlert(SpixiLocalization._SL("app-details-dialog-title"), SpixiLocalization._SL("app-details-dialog-removefailed-text"), SpixiLocalization._SL("global-dialog-ok"));
}
Navigation.PopAsync(Config.defaultXamarinAnimations);
}
private Task SetResultAsync(FingerprintAuthenticationResult result)
{
if (result.Authenticated)
{
performUnlock();
}
else
{
_ = displaySpixiAlert(SpixiLocalization._SL("global-lock-invalidpassword-title"), SpixiLocalization._SL("global-lock-invalidpassword-text"), "Cancel");
}
return(Task.CompletedTask);
}
public MainWindow()
{
InitializeComponent();
this.TaskbarItemInfo = new TaskbarItemInfo();
mainWindow = this;
Forms.Init();
SpixiLocalization.addCustomString("Platform", "Xamarin-WPF");
LoadApplication(SPIXI.App.Instance());
}
public WalletSend2Page(string[] addresses_with_amounts)
{
InitializeComponent();
NavigationPage.SetHasNavigationBar(this, false);
// Go through each entry
foreach (string address_and_amount in addresses_with_amounts)
{
if (address_and_amount.Length < 1)
{
continue;
}
// Extract the address and amount
string[] asplit = address_and_amount.Split(new string[] { ":" }, StringSplitOptions.None);
if (asplit.Count() < 2)
{
continue;
}
string address = asplit[0];
string amount = asplit[1];
byte[] _address = Base58Check.Base58CheckEncoding.DecodePlain(address);
if (Address.validateChecksum(_address) == false)
{
displaySpixiAlert(SpixiLocalization._SL("global-invalid-address-title"), SpixiLocalization._SL("global-invalid-address-text"), SpixiLocalization._SL("global-dialog-ok"));
return;
}
string[] amount_split = amount.Split(new string[] { "." }, StringSplitOptions.None);
if (amount_split.Length > 2)
{
displaySpixiAlert(SpixiLocalization._SL("wallet-error-amount-title"), SpixiLocalization._SL("wallet-error-amountdecimal-text"), SpixiLocalization._SL("global-dialog-ok"));
return;
}
IxiNumber _amount = amount;
if (_amount < (long)0)
{
displaySpixiAlert(SpixiLocalization._SL("wallet-error-amount-title"), SpixiLocalization._SL("wallet-error-amount-text"), SpixiLocalization._SL("global-dialog-ok"));
return;
}
to_list.AddOrReplace(_address, _amount);
totalAmount = totalAmount + _amount;
}
loadPage(webView, "wallet_send_2.html");
}
private void doUnlock(string pass)
{
string target_filepath = Path.Combine(Config.spixiUserFolder, Config.walletFile);
WalletStorage ws = new WalletStorage(target_filepath);
if (!ws.verifyWallet(target_filepath, pass))
{
displaySpixiAlert(SpixiLocalization._SL("intro-restore-file-invalidpassword-title"), SpixiLocalization._SL("intro-restore-file-invalidpassword-text"), SpixiLocalization._SL("global-dialog-ok"));
}
else
{
performUnlock();
}
}
// Shows a file picker to select the wallet file
private async void onSelectFile()
{
byte[] _data = null;
try
{
var picker_service = DependencyService.Get <IFilePicker>();
SpixiImageData fileData = await picker_service.PickFileAsync();
if (fileData == null)
{
return; // User canceled file picking
}
var stream = fileData.stream;
_data = new byte[stream.Length];
stream.Read(_data, 0, (int)stream.Length);
}
catch (Exception ex)
{
Logging.error("Exception choosing file: " + ex.ToString());
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
displaySpixiAlert(SpixiLocalization._SL("intro-restore-file-error-title"), SpixiLocalization._SL("intro-restore-file-selecterror-text"), SpixiLocalization._SL("global-dialog-ok"));
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
return;
}
if (_data == null)
{
await displaySpixiAlert(SpixiLocalization._SL("intro-restore-file-error-title"), SpixiLocalization._SL("intro-restore-file-readerror-text"), SpixiLocalization._SL("global-dialog-ok"));
return;
}
string docpath = Config.spixiUserFolder;
string filepath = Path.Combine(docpath, Config.walletFile + ".tmp");
try
{
File.WriteAllBytes(filepath, _data);
}
catch (Exception ex)
{
Logging.error("Exception caught in process: {0}", ex);
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
displaySpixiAlert(SpixiLocalization._SL("intro-restore-file-error-title"), SpixiLocalization._SL("intro-restore-file-writeerror-text"), SpixiLocalization._SL("global-dialog-ok"));
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
return;
}
Utils.sendUiCommand(webView, "enableRestore");
}
private void onInstall(string path)
{
string app_name = Node.customAppManager.install(path);
if (app_name != null)
{
displaySpixiAlert(SpixiLocalization._SL("app-new-dialog-title"), string.Format(SpixiLocalization._SL("app-new-dialog-installed-text"), app_name), SpixiLocalization._SL("global-dialog-ok"));
Navigation.PopAsync(Config.defaultXamarinAnimations);
}
else
{
displaySpixiAlert(SpixiLocalization._SL("app-new-dialog-title"), SpixiLocalization._SL("app-new-dialog-installfailed-text"), SpixiLocalization._SL("global-dialog-ok"));
}
}
private async void onLoad()
{
if (justConfirmAction)
{
Utils.sendUiCommand(webView, "setJustConfirm", "True");
}
if (Device.RuntimePlatform == Device.WPF)
{
return;
}
// Show biometric and alternative authentication methods
await AuthenticateAsync(SpixiLocalization._SL("global-lock-auth-text"));
}
public async Task onChangeAvatarAsync(object sender, EventArgs e)
{
var picker_service = DependencyService.Get <IFilePicker>();
SpixiImageData spixi_img_data = await picker_service.PickImageAsync();
if (spixi_img_data == null)
{
return;
}
Stream stream = spixi_img_data.stream;
if (stream == null)
{
return;
}
var file_path = Path.Combine(Node.localStorage.avatarsPath, "avatar-tmp.jpg");
try
{
byte[] image_bytes = null;
using (MemoryStream ms = new MemoryStream())
{
stream.CopyTo(ms);
stream.Close();
image_bytes = picker_service.ResizeImage(ms.ToArray(), 960, 960, 80);
if (image_bytes == null)
{
return;
}
}
FileStream fs = new FileStream(file_path, FileMode.OpenOrCreate, FileAccess.Write);
fs.Write(image_bytes, 0, image_bytes.Length);
fs.Close();
}
catch (Exception ex)
{
await displaySpixiAlert(SpixiLocalization._SL("intro-new-avatarerror-title"), ex.ToString(), SpixiLocalization._SL("global-dialog-ok"));
return;
}
Utils.sendUiCommand(webView, "loadAvatar", file_path);
Node.changedSettings = true;
}
public void displayAppRequests()
{
if (_webView == null)
{
return;
}
Utils.sendUiCommand(_webView, "clearAppRequests");
var app_pages = Node.customAppManager.getAppPages();
lock (app_pages)
{
foreach (CustomAppPage page in app_pages.Values)
{
if (page.accepted)
{
continue;
}
Friend f = FriendList.getFriend(page.hostUserAddress);
CustomApp app = Node.customAppManager.getApp(page.appId);
string text = string.Format(SpixiLocalization._SL("global-app-wants-to-use"), f.nickname, app.name);
Utils.sendUiCommand(_webView, "addAppRequest", Crypto.hashToString(page.sessionId), text, SpixiLocalization._SL("global-app-accept"), SpixiLocalization._SL("global-app-reject"));
}
if (VoIPManager.isInitiated())
{
if (VoIPManager.currentCallAccepted)
{
if (VoIPManager.currentCallCalleeAccepted)
{
displayCallBar(VoIPManager.currentCallSessionId, SpixiLocalization._SL("global-call-in-call") + " - " + VoIPManager.currentCallContact.nickname, VoIPManager.currentCallStartedTime);
}
else
{
displayCallBar(VoIPManager.currentCallSessionId, SpixiLocalization._SL("global-call-dialing") + " " + VoIPManager.currentCallContact.nickname + "...", 0);
}
}
else
{
Friend f = VoIPManager.currentCallContact;
string text = SpixiLocalization._SL("global-call-incoming") + " - " + f.nickname;
string accept_html = "<div style='background:#2fd63b;border-radius:16px;width:64px;height:64px;display:table-cell;vertical-align:middle;text-align:center;'><i class='fas fa-phone'></i></div>";
string reject_html = "<div style='background:#de0a61;border-radius:16px;width:64px;height:64px;display:table-cell;vertical-align:middle;text-align:center;'><i class='fas fa-phone-slash'></i></div>";
Utils.sendUiCommand(_webView, "addAppRequest", Crypto.hashToString(VoIPManager.currentCallSessionId), text, accept_html, reject_html);
}
}
}
}
private void onNavigating(object sender, WebNavigatingEventArgs e)
{
string current_url = HttpUtility.UrlDecode(e.Url);
if (onNavigatingGlobal(current_url))
{
e.Cancel = true;
return;
}
if (current_url.Equals("ixian:onload", StringComparison.Ordinal))
{
onLoad();
}
else if (current_url.Equals("ixian:back", StringComparison.Ordinal))
{
Navigation.PopAsync(Config.defaultXamarinAnimations);
}
else if (current_url.Equals("ixian:error", StringComparison.Ordinal))
{
displaySpixiAlert(SpixiLocalization._SL("settings-encryption-invalidpassword-title"), SpixiLocalization._SL("settings-encryption-invalidpassword-text"), SpixiLocalization._SL("global-dialog-ok"));
}
else if (current_url.StartsWith("ixian:changepass:"******"--1ec4ce59e0535704d4--" }, StringSplitOptions.None);
string old_password = split_url[1];
string new_password = split_url[2];
if (IxianHandler.getWalletStorage().isValidPassword(old_password))
{
IxianHandler.getWalletStorage().writeWallet(new_password);
displaySpixiAlert(SpixiLocalization._SL("settings-encryption-passwordchanged-title"), SpixiLocalization._SL("settings-encryption-passwordchanged-text"), SpixiLocalization._SL("global-dialog-ok"));
Navigation.PopAsync(Config.defaultXamarinAnimations);
}
else
{
displaySpixiAlert(SpixiLocalization._SL("settings-encryption-invalidpassword-title"), SpixiLocalization._SL("settings-encryption-invalidpassword-current-text"), SpixiLocalization._SL("global-dialog-ok"));
}
}
else
{
// Otherwise it's just normal navigation
e.Cancel = false;
return;
}
e.Cancel = true;
}
private void onRemove()
{
if (friend.bot && friend.metaData.botInfo != null)
{
friend.pendingDeletion = true;
friend.save();
Node.shouldRefreshContacts = true;
StreamProcessor.sendLeave(friend, null);
displaySpixiAlert(SpixiLocalization._SL("contact-details-removedcontact-title"), SpixiLocalization._SL("contact-details-removedcontact-text"), SpixiLocalization._SL("global-dialog-ok"));
}
else
{
if (FriendList.removeFriend(friend) == true)
{
displaySpixiAlert(SpixiLocalization._SL("contact-details-removedcontact-title"), SpixiLocalization._SL("contact-details-removedcontact-text"), SpixiLocalization._SL("global-dialog-ok"));
}
}
}
public void onRequest(byte[] recipient_address)
{
try
{
if (Address.validateChecksum(recipient_address) == false)
{
displaySpixiAlert(SpixiLocalization._SL("global-invalid-address-title"), SpixiLocalization._SL("global-invalid-address-text"), SpixiLocalization._SL("global-dialog-ok"));
return;
}
if (recipient_address.SequenceEqual(Node.walletStorage.getPrimaryAddress()))
{
displaySpixiAlert(SpixiLocalization._SL("global-invalid-address-title"), SpixiLocalization._SL("contact-new-invalid-address-self-text"), SpixiLocalization._SL("global-dialog-ok"));
return;
}
Friend old_friend = FriendList.getFriend(recipient_address);
if (old_friend != null)
{
if (old_friend.pendingDeletion)
{
FriendList.removeFriend(old_friend);
}
else
{
displaySpixiAlert(SpixiLocalization._SL("global-invalid-address-title"), SpixiLocalization._SL("contact-new-invalid-address-exists-text"), SpixiLocalization._SL("global-dialog-ok"));
return;
}
}
Friend friend = FriendList.addFriend(recipient_address, null, Base58Check.Base58CheckEncoding.EncodePlain(recipient_address), null, null, 0);
if (friend != null)
{
friend.save();
StreamProcessor.sendContactRequest(friend);
}
}catch (Exception)
{
}
Navigation.PopAsync(Config.defaultXamarinAnimations);
}
private HomePage()
{
Node.preStart();
InitializeComponent();
NavigationPage.SetHasBackButton(this, false);
NavigationPage.SetHasNavigationBar(this, false);
string onboarding_complete = "false";
if (Application.Current.Properties.ContainsKey("onboardingComplete"))
{
onboarding_complete = "true";
}
SpixiLocalization.addCustomString("OnboardingComplete", onboarding_complete);
loadPage(webView, "index.html");
if (!running)
{
running = true;
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
try
{
Node.start();
Node.connectToNetwork();
}catch (Exception e)
{
Logging.error("Fatal error has occured: " + e);
displaySpixiAlert("Fatal exception", "Fatal exception has occured, please send the log files to the developers." + e.Message, "OK");
}
}).Start();
// Setup a timer to handle UI updates
Device.StartTimer(TimeSpan.FromSeconds(2), () =>
{
onUpdateUI();
return(running); // True = Repeat again, False = Stop the timer
});
}
}
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"));
}
}
// Attempt to restore the wallet
private void onRestore(string pass)
{
Application.Current.Properties["walletpass"] = pass;
Application.Current.SavePropertiesAsync(); // Force-save properties for compatibility with WPF
string source_path = Path.Combine(Config.spixiUserFolder, Config.walletFile) + ".tmp";
if (!File.Exists(source_path))
{
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
displaySpixiAlert(SpixiLocalization._SL("intro-restore-file-error-title"), SpixiLocalization._SL("intro-restore-file-selecterror-text"), SpixiLocalization._SL("global-dialog-ok"));
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
return;
}
if (restoreAccountFile(source_path, pass))
{
return;
}
restoreWalletFile(source_path, pass);
}