private Task Client_OnStateChanged(object Sender, XmppState NewState)
{
switch (NewState)
{
case XmppState.Connected:
this.isOnline = true;
if (this.credentials is null)
{
this.credentials = new AccountCredentials()
{
Domain = this.domain,
UserName = this.userName,
PasswordHash = this.client.PasswordHash,
PasswordHashMethod = this.client.PasswordHashMethod
};
Database.Insert(this.credentials);
}
break;
case XmppState.Error:
case XmppState.Offline:
this.isOnline = false;
break;
}
this.Model.ExternalEvent(this, "OnStateChanged",
new KeyValuePair <string, object>("NewState", NewState),
new KeyValuePair <string, object>("Client", this.client));
return(Task.CompletedTask);
}
private async Task OnStateChanged(object Sender, XmppState State)
{
switch (State)
{
case XmppState.Connected:
Console.WriteLine("Connected");
this.formW.disableFormGroup();
this.formW.setConnectionStatus(true);
this.AddFeatures();
await this.RegisterDevice();
//this.formW.su
//this.FindSensors();
break;
case XmppState.Error:
this.formW.setConnectionStatus(false);
Console.WriteLine("Connection Error");
break;
case XmppState.Offline:
this.formW.setConnectionStatus(false);
Console.WriteLine("Connection Error");
break;
}
}
private static void XmppClient_OnStateChanged(object Sender, XmppState NewState)
{
switch (NewState)
{
case XmppState.Connected:
connected = true;
MarkdownToHtmlConverter.BareJID = xmppClient.BareJID;
if (!registered && thingRegistryClient != null)
{
Register();
}
if (!socksProxy.HasProxy)
{
socksProxy.StartSearch(null);
}
break;
case XmppState.Offline:
immediateReconnect = connected;
connected = false;
if (immediateReconnect && xmppClient != null)
{
xmppClient.Reconnect();
}
break;
}
}
private Task XmppClient_OnStateChanged(object _, XmppState NewState)
{
this.state = NewState;
if (NewState == XmppState.Connected)
{
this.CallCallbacks();
}
else if (NewState == XmppState.Error || NewState == XmppState.Offline)
{
if (!(this.parent is null))
{
this.parent.PeerClosed(this);
}
if (!(this.xmppClient is null))
{
this.xmppClient.Dispose();
this.xmppClient = null;
}
this.CallCallbacks();
}
return(Task.CompletedTask);
}
private void DestroyContractsClient()
{
XmppState stateBefore = GetState();
if (!(this.contractsClient is null))
{
this.contractsClient.IdentityUpdated -= ContractsClient_IdentityUpdated;
this.contractsClient.PetitionForIdentityReceived -= ContractsClient_PetitionForIdentityReceived;
this.contractsClient.PetitionedIdentityResponseReceived -= ContractsClient_PetitionedIdentityResponseReceived;
this.contractsClient.PetitionForContractReceived -= ContractsClient_PetitionForContractReceived;
this.contractsClient.PetitionedContractResponseReceived -= ContractsClient_PetitionedContractResponseReceived;
this.contractsClient.PetitionForSignatureReceived -= ContractsClient_PetitionForSignatureReceived;
this.contractsClient.PetitionedSignatureResponseReceived -= ContractsClient_PetitionedSignatureResponseReceived;
this.contractsClient.PetitionForPeerReviewIDReceived -= ContractsClient_PetitionForPeerReviewIdReceived;
this.contractsClient.PetitionedPeerReviewIDResponseReceived -= ContractsClient_PetitionedPeerReviewIdResponseReceived;
this.contractsClient.Dispose();
this.contractsClient = null;
}
XmppState stateAfter = GetState();
if (stateBefore != stateAfter)
{
this.OnConnectionStateChanged(new ConnectionStateChangedEventArgs(stateAfter, false));
}
}
private static string StateToString(XmppState State)
{
switch (State)
{
case XmppState.Offline: return("Offline");
case XmppState.Connecting: return("Connecting");
case XmppState.StreamNegotiation: return("Negotiating stream");
case XmppState.StreamOpened: return("Opened stream");
case XmppState.StartingEncryption: return("Starting encryption");
case XmppState.Authenticating: return("Authenticating");
case XmppState.Registering: return("Registering");
case XmppState.Binding: return("Binding");
case XmppState.RequestingSession: return("Requesting session");
case XmppState.FetchingRoster: return("Fetching roster");
case XmppState.SettingPresence: return("Setting presence");
case XmppState.Connected: return("Connected");
case XmppState.Error: return("In error");
default: return("Unknown");
}
}
private void Client_OnStateChanged(object Sender, XmppState NewState)
{
switch (NewState)
{
case XmppState.Connected:
this.connected = true;
this.lastError = null;
if (string.IsNullOrEmpty(this.passwordHash))
{
this.passwordHash = this.client.PasswordHash;
this.passwordHashMethod = this.client.PasswordHashMethod;
}
this.CheckRoster();
break;
case XmppState.Offline:
bool ImmediateReconnect = this.connected;
this.connected = false;
if (ImmediateReconnect && this.client != null)
{
this.client.Reconnect();
}
break;
}
this.OnUpdated();
}
private async Task TestConnectionStateChanged(object Sender, XmppState State)
{
Log.Informational("Changing state: " + State.ToString());
switch (State)
{
case XmppState.Connected:
await RuntimeSettings.SetAsync("XmppHost", this.xmppClient.Host);
await RuntimeSettings.SetAsync("XmppPort", this.xmppClient.Port);
await RuntimeSettings.SetAsync("XmppUserName", this.xmppClient.UserName);
await RuntimeSettings.SetAsync("XmppPasswordHash", this.xmppClient.PasswordHash);
await RuntimeSettings.SetAsync("XmppPasswordHashMethod", this.xmppClient.PasswordHashMethod);
this.xmppClient.OnStateChanged -= this.TestConnectionStateChanged;
this.xmppClient.OnStateChanged += this.StateChanged;
await this.SetVCard();
await this.RegisterDevice();
break;
case XmppState.Error:
case XmppState.Offline:
if (!(this.xmppClient is null))
{
await MainPage.Instance.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => await this.ShowConnectionDialog(this.xmppClient.Host, this.xmppClient.Port, this.xmppClient.UserName));
}
break;
}
}
private void XmppStateChanged(object P)
{
XmppState NewState = (XmppState)P;
switch (NewState)
{
case XmppState.Offline:
this.ConnectionState.Content = "Offline.";
break;
case XmppState.Connecting:
this.ConnectionState.Content = "Connecting.";
break;
case XmppState.StreamNegotiation:
this.ConnectionState.Content = "Stream negotiation.";
break;
case XmppState.StreamOpened:
this.ConnectionState.Content = "Stream opened.";
break;
case XmppState.StartingEncryption:
this.ConnectionState.Content = "Starting encryption.";
break;
case XmppState.Authenticating:
this.ConnectionState.Content = "Authenticating user.";
break;
case XmppState.Registering:
this.ConnectionState.Content = "Registering account.";
break;
case XmppState.Binding:
this.ConnectionState.Content = "Binding resource.";
break;
case XmppState.FetchingRoster:
this.ConnectionState.Content = "Fetching roster.";
break;
case XmppState.SettingPresence:
this.ConnectionState.Content = "Setting presence.";
break;
case XmppState.Connected:
this.passwordHash = this.client.PasswordHash;
this.passwordHashMethod = this.client.PasswordHashMethod;
this.ConnectionState.Content = "Connected.";
this.CloseClient();
this.DialogResult = true;
break;
case XmppState.Error:
this.ConnectionState.Content = "Error.";
this.CloseClient();
break;
}
}
private void ToError()
{
this.inputState = -1;
this.state = XmppState.Error;
this.CallCallbacks();
this.peer?.Dispose();
this.peer = null;
}
private void StateChanged(object Sender, XmppState State)
{
Log.Informational("Changing state: " + State.ToString());
if (State == XmppState.Connected)
{
Log.Informational("Connected as " + this.xmppClient.FullJID);
Task.Run(this.SetVCard);
Task.Run(this.RegisterDevice);
}
}
private Task StateChanged(object _, XmppState State)
{
Log.Informational("Changing state: " + State.ToString());
if (State == XmppState.Connected)
{
Log.Informational("Connected as " + this.xmppClient.FullJID);
Task.Run(this.SetVCard);
Task.Run(this.RegisterDevice);
}
return(Task.CompletedTask);
}
private void XmppClient_OnStateChanged(object Sender, XmppState NewState)
{
if (NewState == XmppState.Offline || NewState == XmppState.Error || NewState == XmppState.Connected)
{
string[] TabIDs = this.GetTabIDs();
if (TabIDs.Length > 0 && !(Gateway.XmppClient is null))
{
string Json = JSON.Encode(new KeyValuePair <string, object>[]
{
new KeyValuePair <string, object>("html", this.RosterItemsHtml(Gateway.XmppClient.Roster, Gateway.XmppClient.SubscriptionRequests))
}, false);
ClientEvents.PushEvent(TabIDs, "UpdateRoster", Json, true, "User");
}
}
}
private void Component_OnStateChanged(object Sender, XmppState NewState)
{
switch (NewState)
{
case XmppState.Connected:
this.componentConnected.Set();
break;
case XmppState.Error:
this.componentError.Set();
break;
case XmppState.Offline:
this.componentOffline.Set();
break;
}
}
/// <summary>
/// Converts the state to a localized string.
/// </summary>
/// <param name="state">The state to convert.</param>
/// <param name="domain">The domain, if any.</param>
/// <returns></returns>
public static string ToDisplayText(this XmppState state, string domain)
{
switch (state)
{
case XmppState.Authenticating:
return(AppResources.XmppState_Authenticating);
case XmppState.Binding:
return(AppResources.XmppState_Binding);
case XmppState.Connected:
return(!string.IsNullOrWhiteSpace(domain)
? string.Format(AppResources.XmppState_ConnectedTo, domain)
: AppResources.XmppState_Connected);
case XmppState.Connecting:
return(AppResources.XmppState_Connecting);
case XmppState.Error:
return(AppResources.XmppState_Error);
case XmppState.FetchingRoster:
return(AppResources.XmppState_FetchingRoster);
case XmppState.Registering:
return(AppResources.XmppState_Registering);
case XmppState.RequestingSession:
return(AppResources.XmppState_RequestingSession);
case XmppState.SettingPresence:
return(AppResources.XmppState_SettingPresence);
case XmppState.StartingEncryption:
return(AppResources.XmppState_StartingEncryption);
case XmppState.StreamNegotiation:
return(AppResources.XmppState_StreamNegotiation);
case XmppState.StreamOpened:
return(AppResources.XmppState_StreamOpened);
default:
return(AppResources.XmppState_Offline);
}
}
private void Client_OnStateChanged(object Sender, XmppState NewState)
{
switch (NewState)
{
case XmppState.Connected:
this.BeginSearchSupport();
break;
case XmppState.Offline:
case XmppState.Error:
this.supportsBlocking = false;
this.supportsReporting = false;
this.supportsSpamReason = false;
this.supportsAbuseReason = false;
break;
}
}
private Task Client_OnStateChanged(object _, XmppState NewState)
{
switch (NewState)
{
case XmppState.Connected:
this.BeginSearchSupport();
break;
case XmppState.Offline:
case XmppState.Error:
this.supportsBlocking = false;
this.supportsReporting = false;
this.supportsSpamReason = false;
this.supportsAbuseReason = false;
break;
}
return(Task.CompletedTask);
}
private Task Component_OnStateChanged(object Sender, XmppState NewState)
{
switch (NewState)
{
case XmppState.Connected:
this.componentConnected.Set();
break;
case XmppState.Error:
this.componentError.Set();
break;
case XmppState.Offline:
this.componentOffline.Set();
break;
}
return(Task.CompletedTask);
}
private void Client_OnStateChanged1(object Sender, XmppState NewState)
{
switch (NewState)
{
case XmppState.Connected:
this.connected1.Set();
break;
case XmppState.Error:
this.error1.Set();
break;
case XmppState.Offline:
this.offline1.Set();
break;
case XmppState.Connecting:
break;
}
}
private async void TestConnectionStateChanged(object Sender, XmppState State)
{
try
{
this.StateChanged(Sender, State);
switch (State)
{
case XmppState.Connected:
await RuntimeSettings.SetAsync("XmppHost", this.xmppClient.Host);
await RuntimeSettings.SetAsync("XmppPort", this.xmppClient.Port);
await RuntimeSettings.SetAsync("XmppUserName", this.xmppClient.UserName);
await RuntimeSettings.SetAsync("XmppPasswordHash", this.xmppClient.PasswordHash);
await RuntimeSettings.SetAsync("XmppPasswordHashMethod", this.xmppClient.PasswordHashMethod);
this.xmppClient.OnStateChanged -= this.TestConnectionStateChanged;
this.xmppClient.OnStateChanged += this.StateChanged;
this.AttachFeatures();
await this.SetVCard();
await this.RegisterDevice();
break;
case XmppState.Error:
case XmppState.Offline:
await MainPage.Instance.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => await this.ShowConnectionDialog(this.xmppClient.Host, this.xmppClient.Port, this.xmppClient.UserName));
break;
}
}
catch (Exception ex)
{
Log.Critical(ex);
}
}
private Task Client_OnStateChanged(object _, XmppState NewState)
{
switch (NewState)
{
case XmppState.Connected:
uint i;
lock (this.synchObj)
{
i = this.eventsLost;
this.eventsLost = 0;
this.connected = true;
}
if (i > 0)
{
Log.Notice(i.ToString() + " events lost while XMPP connection was down.",
this.ObjectID, string.Empty, "EventsLost", new KeyValuePair <string, object>("Nr", i));
}
break;
case XmppState.Offline:
bool ImmediateReconnect;
lock (this.synchObj)
{
ImmediateReconnect = this.connected;
this.connected = false;
}
if (ImmediateReconnect && this.timer != null)
{
this.client.Reconnect();
}
break;
}
return(Task.CompletedTask);
}
private Task Client_OnStateChanged2(object Sender, XmppState NewState)
{
switch (NewState)
{
case XmppState.Connected:
this.connected2.Set();
break;
case XmppState.Error:
this.error2.Set();
break;
case XmppState.Offline:
this.offline2.Set();
break;
case XmppState.Connecting:
break;
}
return(Task.CompletedTask);
}
private void Client_OnStateChanged(object Sender, XmppState NewState)
{
switch (NewState)
{
case XmppState.Connected:
this.connected = true;
this.lastError = null;
if (this.supportsHashes && string.IsNullOrEmpty(this.passwordHash))
{
this.passwordHash = this.client.PasswordHash;
this.passwordHashMethod = this.client.PasswordHashMethod;
this.connections.Modified = true;
}
if (this.domain != this.client.Domain)
{
this.domain = this.client.Domain;
this.connections.Modified = true;
}
this.CheckRoster();
this.SearchComponents();
break;
case XmppState.Offline:
bool ImmediateReconnect = this.connected;
this.connected = false;
if (ImmediateReconnect && this.client != null)
{
this.client.Reconnect();
}
break;
}
this.OnUpdated();
}
private async Task CreateContractsClient(bool CanCreateKeys)
{
if (!string.IsNullOrWhiteSpace(this.tagProfile.LegalJid))
{
DestroyContractsClient();
XmppState stateBefore = GetState();
this.contractsClient = await this.neuronService.CreateContractsClientAsync(CanCreateKeys);
this.contractsClient.IdentityUpdated += ContractsClient_IdentityUpdated;
this.contractsClient.PetitionForIdentityReceived += ContractsClient_PetitionForIdentityReceived;
this.contractsClient.PetitionedIdentityResponseReceived += ContractsClient_PetitionedIdentityResponseReceived;
this.contractsClient.PetitionForContractReceived += ContractsClient_PetitionForContractReceived;
this.contractsClient.PetitionedContractResponseReceived += ContractsClient_PetitionedContractResponseReceived;
this.contractsClient.PetitionForSignatureReceived += ContractsClient_PetitionForSignatureReceived;
this.contractsClient.PetitionedSignatureResponseReceived += ContractsClient_PetitionedSignatureResponseReceived;
this.contractsClient.PetitionForPeerReviewIDReceived += ContractsClient_PetitionForPeerReviewIdReceived;
this.contractsClient.PetitionedPeerReviewIDResponseReceived += ContractsClient_PetitionedPeerReviewIdResponseReceived;
XmppState stateAfter = GetState();
if (stateBefore != stateAfter)
{
this.OnConnectionStateChanged(new ConnectionStateChangedEventArgs(stateAfter, false));
}
}
}
private void XmppClient_OnStateChanged(object Sender, XmppState NewState)
{
this.state = NewState;
if (NewState == XmppState.Connected)
{
this.CallCallbacks();
}
else if (NewState == XmppState.Error || NewState == XmppState.Offline)
{
if (this.parent != null)
{
this.parent.PeerClosed(this);
}
if (this.xmppClient != null)
{
this.xmppClient.Dispose();
this.xmppClient = null;
}
this.CallCallbacks();
}
}
private void ProcessStream(string Xml)
{
try
{
int i = Xml.IndexOf("?>");
if (i >= 0)
{
Xml = Xml.Substring(i + 2).TrimStart();
}
this.streamHeader = Xml;
i = Xml.IndexOf(":stream");
if (i < 0)
{
this.streamFooter = "</stream>";
}
else
{
this.streamFooter = "</" + Xml.Substring(1, i - 1) + ":stream>";
}
XmlDocument Doc = new XmlDocument()
{
PreserveWhitespace = true
};
Doc.LoadXml(Xml + this.streamFooter);
if (Doc.DocumentElement.LocalName != "stream")
{
throw new XmppException("Invalid stream.", Doc.DocumentElement);
}
XmlElement Stream = Doc.DocumentElement;
this.version = XML.Attribute(Stream, "version", 0.0);
this.streamId = XML.Attribute(Stream, "id");
this.remoteFullJid = XML.Attribute(Stream, "from");
if (this.version < 1.0)
{
throw new XmppException("Version not supported.", Stream);
}
if (this.parentFullJid != XML.Attribute(Stream, "to"))
{
throw new XmppException("Invalid destination JID.", Stream);
}
this.state = XmppState.Authenticating;
string Header = "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' from='" +
this.parentFullJid + "' to='" + this.remoteFullJid + "' version='1.0'>";
try
{
this.parent.AuthenticatePeer(this.peer, this.remoteFullJid);
}
catch (Exception ex)
{
this.parent.Exception(ex);
Header += "<stream:error><invalid-from xmlns='urn:ietf:params:xml:ns:xmpp-streams'/>" +
"<text xmlns='urn:ietf:params:xml:ns:xmpp-streams'>" + XML.Encode(ex.Message) +
"</text></stream:error></stream:stream>";
this.headerSent = true;
this.SendAsync(Header, (sender, e) =>
{
this.ToError();
});
return;
}
if (!this.headerSent)
{
this.headerSent = true;
this.SendAsync(Header);
}
this.state = XmppState.Connected;
this.xmppClient = new XmppClient(this, this.state, Header, "</stream:stream>", this.parentFullJid,
typeof(XmppServerlessMessaging).GetTypeInfo().Assembly)
{
SendFromAddress = true
};
this.parent.PeerAuthenticated(this);
this.parent.NewXmppClient(this.xmppClient, this.parentFullJid, this.remoteFullJid);
this.xmppClient.OnStateChanged += this.XmppClient_OnStateChanged;
this.CallCallbacks();
}
catch (Exception ex)
{
this.parent.Exception(ex);
this.ToError();
}
}
private void Client_OnStateChanged(object Sender, XmppState NewState)
{
this.Dispatcher.BeginInvoke(new ParameterizedThreadStart(this.XmppStateChanged), NewState);
}
private Task Client_OnStateChanged(object Sender, XmppState NewState)
{
MainWindow.UpdateGui(this.XmppStateChanged, NewState);
return(Task.CompletedTask);
}
/// <inheritdoc/>
protected override void SetConnectionStateAndText(XmppState state)
{
this.ConnectionStateText = state.ToDisplayText(this.tagProfile.Domain);
this.IsConnected = state == XmppState.Connected;
}
private void SetConnectionStateAndText(XmppState state)
{
IsConnected = state == XmppState.Connected;
this.ConnectionStateText = state.ToDisplayText(null);
}
