private bool onRequestBundleInformationMessage(IQMessage msg)
{
if (STATE != OmemoSessionBuildHelperState.REQUESTING_BUNDLE_INFORMATION)
{
return(true);
}
if (msg is OmemoBundleInformationResultMessage bundleMsg)
{
Logger.Info("[OmemoSessionBuildHelper] Session with " + curAddress.getName() + ':' + curAddress.getDeviceId() + " established.");
SignalProtocolAddress address = OMEMO_HELPER.newSession(CHAT_JID, bundleMsg);
SessionCipher cipher = OMEMO_HELPER.loadCipher(address);
SESSION.DEVICE_SESSIONS.Add(curAddress.getDeviceId(), cipher);
createSessionForNextDevice();
return(true);
}
else if (msg is IQErrorMessage errMsg)
{
if (errMsg.ERROR_OBJ.ERROR_NAME == ErrorName.ITEM_NOT_FOUND)
{
Logger.Error("[OmemoSessionBuildHelper] Failed to establish session - " + curAddress.getName() + ':' + curAddress.getDeviceId() + " doesn't support OMEMO: " + errMsg.ERROR_OBJ.ToString());
setState(OmemoSessionBuildHelperState.ERROR);
ON_SESSION_RESULT(this, new OmemoSessionBuildResult(OmemoSessionBuildError.TARGET_DOES_NOT_SUPPORT_OMEMO));
}
else
{
Logger.Error("[OmemoSessionBuildHelper] Failed to establish session - request bundle info failed(" + curAddress.getName() + ':' + curAddress.getDeviceId() + "): " + errMsg.ERROR_OBJ.ToString());
setState(OmemoSessionBuildHelperState.ERROR);
ON_SESSION_RESULT(this, new OmemoSessionBuildResult(OmemoSessionBuildError.REQUEST_BUNDLE_INFORMATION_IQ_ERROR));
}
return(true);
}
return(false);
}
private bool onKickMessage(IQMessage msg)
{
if (msg is IQErrorMessage)
{
IQErrorMessage errorMessage = msg as IQErrorMessage;
Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
error_itbx.Text = "Type: " + errorMessage.ERROR_OBJ.ERROR_NAME + "\nMessage: " + errorMessage.ERROR_OBJ.ERROR_MESSAGE;
error_itbx.Visibility = Visibility.Visible;
enableButtons();
}).AsTask();
return(true);
}
if (Equals(msg.TYPE, IQMessage.RESULT))
{
Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
done_itbx.Text = "Success! Occupant got kicked.";
done_itbx.Visibility = Visibility.Visible;
kickSingle_prgr.Visibility = Visibility.Collapsed;
}).AsTask();
return(true);
}
return(false);
}
private bool onSaveMessage(MessageResponseHelper <IQMessage> helper, IQMessage msg)
{
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (msg is IQErrorMessage errorMessage)
{
notificationBanner_ian.Show("Failed to save! Server responded:\nType: " + errorMessage.ERROR_OBJ.ERROR_NAME + "\nMessage: " + errorMessage.ERROR_OBJ.ERROR_MESSAGE);
}
else
{
switch (msg.TYPE)
{
case IQMessage.RESULT:
notificationBanner_ian.Show("Successfully saved room configuration.", 5000);
break;
case IQMessage.ERROR:
default:
notificationBanner_ian.Show("Failed to save! Unknown error. Please retry.");
break;
}
}
save_prgr.Visibility = Visibility.Collapsed;
save_prgr.IsActive = false;
save_btn.IsEnabled = true;
}).AsTask();
return(true);
}
private bool onRequestBanListMessage(IQMessage iq)
{
if (iq is IQErrorMessage)
{
IQErrorMessage errorMessage = iq as IQErrorMessage;
Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
showErrorMessage("Type: " + errorMessage.ERROR_OBJ.ERROR_NAME + "\nMessage: " + errorMessage.ERROR_OBJ.ERROR_MESSAGE);
reload_btn.IsEnabled = true;
reload_prgr.Visibility = Visibility.Collapsed;
}).AsTask();
return(true);
}
else if (iq is BanListMessage)
{
BanListMessage banListMessage = iq as BanListMessage;
Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
banedUsers.Clear();
foreach (BanedUser user in banListMessage.BANED_USERS)
{
banedUsers.Add(new MUCBanedUserTemplate()
{
banedUser = user
});
}
reload_btn.IsEnabled = true;
reload_prgr.Visibility = Visibility.Collapsed;
}).AsTask();
return(true);
}
return(false);
}
private bool onUpdateBanListMessage(IQMessage iq)
{
if (iq is IQErrorMessage)
{
IQErrorMessage errorMessage = iq as IQErrorMessage;
Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
showErrorMessage("Type: " + errorMessage.ERROR_OBJ.ERROR_NAME + "\nMessage: " + errorMessage.ERROR_OBJ.ERROR_MESSAGE);
unban_btn.IsEnabled = true;
reload_btn.IsEnabled = true;
unban_prgr.Visibility = Visibility.Collapsed;
}).AsTask();
return(true);
}
else
{
Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
requestBanList();
unban_btn.IsEnabled = true;
reload_btn.IsEnabled = true;
unban_prgr.Visibility = Visibility.Collapsed;
}).AsTask();
return(true);
}
}
private bool onSubscribeToDeviceListMessage(IQMessage msg)
{
if (STATE != OmemoSessionBuildHelperState.SUBSCRIBING_TO_DEVICE_LIST)
{
return(true);
}
if (msg is PubSubSubscriptionMessage subMsg)
{
if (subMsg.SUBSCRIPTION != PubSubSubscription.SUBSCRIBED)
{
Logger.Warn("[OmemoSessionBuildHelper] Failed to subscribe to device list node - " + CHAT_JID + " returned: " + subMsg.SUBSCRIPTION);
OmemoDeviceDBManager.INSTANCE.setDeviceListSubscription(new OmemoDeviceListSubscriptionTable(CHAT_JID, BARE_ACCOUNT_JID, OmemoDeviceListSubscriptionState.NONE, DateTime.Now));
}
else
{
OmemoDeviceDBManager.INSTANCE.setDeviceListSubscription(new OmemoDeviceListSubscriptionTable(CHAT_JID, BARE_ACCOUNT_JID, OmemoDeviceListSubscriptionState.SUBSCRIBED, DateTime.Now));
}
return(true);
}
else if (msg is IQErrorMessage errMsg)
{
if (errMsg.ERROR_OBJ.ERROR_NAME == ErrorName.ITEM_NOT_FOUND)
{
Logger.Error("[OmemoSessionBuildHelper] Failed to subscribe to device list node - " + CHAT_JID + " returned node does not exist: " + errMsg.ERROR_OBJ.ToString());
}
else
{
Logger.Warn("[OmemoSessionBuildHelper] Failed to subscribe to device list node: " + errMsg.ERROR_OBJ.ToString());
}
OmemoDeviceDBManager.INSTANCE.setDeviceListSubscription(new OmemoDeviceListSubscriptionTable(CHAT_JID, BARE_ACCOUNT_JID, OmemoDeviceListSubscriptionState.ERROR, DateTime.Now));
return(true);
}
return(false);
}
internal void OnSendIQMessage(IQMessage sender, EventArgs args)
{
if (SendIQMessage != null)
{
mCounter++;
SendIQMessage(sender, args);
}
}
internal void OnSendIQMessage(IQMessage sender, EventArgs args)
{
if (SendIQMessage != null)
{
mCounter++;
SendIQMessage(sender, args);
}
}
public bool BindInvoker(IQMessage invoker)
{
if (invokerDic.ContainsKey(invoker.GUID))
{
return(false);
}
invokerDic.Add(invoker.GUID, invoker);
return(true);
}
public bool UnbindInvoker(IQMessage invoker)
{
if (invokerDic.ContainsKey(invoker.GUID))
{
invokerDic.Remove(invoker.GUID);
return(true);
}
return(false);
}
private string ProcessMsg(string message, IQMessage invoker)
{
var returnMsg = invoker.Process(message);
if (invoker.ShowTail)
{
returnMsg += string.Format("【{0}】", invoker.AppName);
}
return(returnMsg);
}
protected async override Task processMessageAsync(NewValidMessageEventArgs args)
{
AbstractMessage msg = args.MESSAGE;
if (state == RecourceBindingState.BOUND || state == RecourceBindingState.ERROR || msg.isProcessed())
{
return;
}
switch (state)
{
case RecourceBindingState.UNBOUND:
if (msg is StreamFeaturesMessage || msg is OpenStreamAnswerMessage)
{
StreamFeaturesMessage features;
if (msg is OpenStreamAnswerMessage)
{
features = (msg as OpenStreamAnswerMessage).getStreamFeaturesMessage();
}
else
{
features = msg as StreamFeaturesMessage;
}
if (features is null)
{
return;
}
if (features.containsFeature("bind"))
{
setMessageProcessed(args);
BindResourceMessage bindMsg = new BindResourceMessage(XMPP_CONNECTION.account.user.resourcePart);
id = bindMsg.ID;
await XMPP_CONNECTION.SendAsync(bindMsg, true);
state = RecourceBindingState.BINDING;
}
}
break;
case RecourceBindingState.BINDING:
if (msg is IQMessage)
{
IQMessage iQM = msg as IQMessage;
if (string.Equals(iQM.ID, id))
{
stopListeningForMessages();
setMessageProcessed(args);
XMPP_CONNECTION.SendAsync(new StartSessionMessage(), true).Wait();
state = RecourceBindingState.BOUND;
ResourceBound?.Invoke(this, new EventArgs());
}
}
break;
}
}
private void processMessage(AbstractMessage msg)
{
if (msg is DiscoReservedRoomNicknamesResponseMessages)
{
DiscoReservedRoomNicknamesResponseMessages result = msg as DiscoReservedRoomNicknamesResponseMessages;
}
else if (msg is IQMessage)
{
IQMessage iq = msg as IQMessage;
}
}
private bool onDiscoMsg(MessageResponseHelper <IQMessage> helper, IQMessage msg)
{
if (msg is DiscoResponseMessage disco)
{
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => showDiscoResult(disco)).AsTask();
return(true);
}
else if (msg is IQErrorMessage error)
{
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => showDiscoError(error)).AsTask();
return(true);
}
return(false);
}
private bool onRemoveMessage(IQMessage msg)
{
if (msg is IQErrorMessage errMsg)
{
Logger.Warn("Failed to set bookmarks: " + errMsg.ToString());
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => noneFound_notification.Show("Failed to add bookmark - server error!\n" + errMsg.ToString())).AsTask();
return(true);
}
if (string.Equals(msg.TYPE, IQMessage.RESULT))
{
return(true);
}
return(false);
}
private bool onMessage(IQMessage msg)
{
if (msg is IQErrorMessage errorMsg)
{
Logging.Logger.Error("Failed to add bookmark! " + msg.ToString());
Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => showError("Failed - see logs!")).AsTask();
}
else
{
success = true;
Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => Hide()).AsTask();
}
return(true);
}
private bool onDiscoMessage(MessageResponseHelper <IQMessage> helper, IQMessage msg)
{
if (msg is DiscoResponseMessage disco)
{
switch (disco.DISCO_TYPE)
{
case DiscoType.ITEMS:
break;
case DiscoType.INFO:
bool foundCarbons = false;
foreach (DiscoFeature f in disco.FEATURES)
{
if (string.Equals(f.VAR, Consts.XML_XEP_0280_NAMESPACE))
{
foundCarbons = true;
if (CONNECTION.account.connectionConfiguration.disableMessageCarbons)
{
CONNECTION.account.CONNECTION_INFO.msgCarbonsState = MessageCarbonsState.DISABLED;
}
else if (CONNECTION.account.CONNECTION_INFO.msgCarbonsState != MessageCarbonsState.ENABLED)
{
Logger.Info("Enabling message carbons for " + CONNECTION.account.getBareJid() + " ...");
carbonsMessageResponseHelper = new MessageResponseHelper <IQMessage>(CONNECTION, onCarbonsMessage, onCarbonsTimeout);
carbonsMessageResponseHelper.start(new CarbonsEnableMessage(CONNECTION.account.getFullJid()));
}
break;
}
}
if (!foundCarbons)
{
Logger.Warn("Unable to enable message carbons for " + CONNECTION.account.getBareJid() + " - not available.");
CONNECTION.account.CONNECTION_INFO.msgCarbonsState = MessageCarbonsState.UNAVAILABLE;
}
break;
default:
break;
}
return(true);
}
else if (msg is IQErrorMessage errMsg)
{
CONNECTION.account.CONNECTION_INFO.msgCarbonsState = MessageCarbonsState.UNAVAILABLE;
Logger.Error("Failed to request initial server disco for " + CONNECTION.account.getBareJid() + ": " + errMsg.ERROR_OBJ.ToString());
return(true);
}
return(false);
}
private bool onCarbonsMessage(MessageResponseHelper <IQMessage> helper, IQMessage msg)
{
if (msg is IQErrorMessage errMsg)
{
CONNECTION.account.CONNECTION_INFO.msgCarbonsState = MessageCarbonsState.ERROR;
Logger.Error("Failed to enable message carbons for " + CONNECTION.account.getBareJid() + ": " + errMsg.ERROR_OBJ.ToString());
return(true);
}
else if (string.Equals(msg.TYPE, IQMessage.RESULT))
{
Logger.Info("Message carbons enabled for " + CONNECTION.account.getBareJid());
CONNECTION.account.CONNECTION_INFO.msgCarbonsState = MessageCarbonsState.ENABLED;
return(true);
}
return(false);
}
private bool onSetBookmarkMessage(IQMessage msg)
{
if (msg is IQErrorMessage errMsg)
{
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
TextDialog dialog = new TextDialog("Failed to bookmark!\nServer responded: " + errMsg.ERROR_OBJ.ERROR_NAME, "Error");
Task t = UiUtils.showDialogAsyncQueue(dialog);
}).AsTask();
return(true);
}
if (string.Equals(msg.TYPE, IQMessage.RESULT))
{
return(true);
}
return(false);
}
private bool onResetDeviceListStatelessMessage(IQMessage msg)
{
if (msg is IQErrorMessage errMsg)
{
resetDeviceListStatelessOnResult?.Invoke(false);
resetDeviceListStatelessOnResult = null;
return(true);
}
else if (msg is IQMessage)
{
DEVICES.DEVICES.Clear();
DEVICES.DEVICES.Add(CONNECTION.account.omemoDeviceId);
resetDeviceListStatelessOnResult?.Invoke(true);
resetDeviceListStatelessOnResult = null;
return(true);
}
return(false);
}
private bool onRequestDeviceListMessage(IQMessage msg)
{
if (STATE != OmemoSessionBuildHelperState.REQUESTING_DEVICE_LIST)
{
return(true);
}
if (msg is OmemoDeviceListResultMessage devMsg)
{
// Update devices in DB:
string chatJid = Utils.getBareJidFromFullJid(devMsg.getFrom());
OmemoDeviceDBManager.INSTANCE.setDevices(devMsg.DEVICES, chatJid, BARE_ACCOUNT_JID);
if (devMsg.DEVICES.DEVICES.Count > 0)
{
subscribeToDeviceList();
createSessionsForDevices(devMsg.DEVICES.DEVICES);
}
else
{
Logger.Error("[OmemoSessionBuildHelper] Failed to establish session - " + CHAT_JID + " doesn't support OMEMO: No devices");
setState(OmemoSessionBuildHelperState.ERROR);
ON_SESSION_RESULT(this, new OmemoSessionBuildResult(OmemoSessionBuildError.TARGET_DOES_NOT_SUPPORT_OMEMO));
}
return(true);
}
else if (msg is IQErrorMessage errMsg)
{
if (errMsg.ERROR_OBJ.ERROR_NAME == ErrorName.ITEM_NOT_FOUND)
{
Logger.Error("[OmemoSessionBuildHelper] Failed to establish session - " + CHAT_JID + " doesn't support OMEMO: " + errMsg.ERROR_OBJ.ToString());
setState(OmemoSessionBuildHelperState.ERROR);
ON_SESSION_RESULT(this, new OmemoSessionBuildResult(OmemoSessionBuildError.TARGET_DOES_NOT_SUPPORT_OMEMO));
}
else
{
Logger.Error("[OmemoSessionBuildHelper] Failed to establish session - request device list failed: " + errMsg.ERROR_OBJ.ToString());
setState(OmemoSessionBuildHelperState.ERROR);
ON_SESSION_RESULT(this, new OmemoSessionBuildResult(OmemoSessionBuildError.REQUEST_DEVICE_LIST_IQ_ERROR));
}
return(true);
}
return(false);
}
private bool onNewMessage(IQMessage iq)
{
if (iq is RoomInfoMessage)
{
RoomInfoMessage responseMessage = iq as RoomInfoMessage;
// Add controls and update viability:
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
fields.Clear();
roomConfigType_tbx.Text = "Configuration level: " + Utils.mucAffiliationToString(responseMessage.CONFIG_LEVEL);
foreach (Field o in responseMessage.ROOM_CONFIG.FIELDS)
{
if (o.type != FieldType.HIDDEN)
{
fields.Add(new MUCInfoFieldTemplate()
{
field = o
});
}
}
reload_btn.IsEnabled = true;
notificationBanner_ian.Dismiss();
timeout_stckpnl.Visibility = Visibility.Collapsed;
loading_grid.Visibility = Visibility.Collapsed;
info_grid.Visibility = Visibility.Visible;
}).AsTask();
return(true);
}
else if (iq is IQErrorMessage errorMessage)
{
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
fields.Clear();
retry_btn.IsEnabled = true;
info_grid.Visibility = Visibility.Collapsed;
loading_grid.Visibility = Visibility.Collapsed;
timeout_stckpnl.Visibility = Visibility.Visible;
notificationBanner_ian.Show("Failed to request configuration! Server responded:\nType: " + errorMessage.ERROR_OBJ.ERROR_NAME + "\nMessage: " + errorMessage.ERROR_OBJ.ERROR_MESSAGE);
}).AsTask();
}
return(false);
}
private bool onMessage(MessageResponseHelper <IQMessage> helper, IQMessage iq)
{
if (iq is DiscoResponseMessage)
{
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => showResultDisco(iq as DiscoResponseMessage)).AsTask();
return(true);
}
else if (iq is IQErrorMessage errorMessage)
{
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
loading_grid.Visibility = Visibility.Collapsed;
main_grid.Visibility = Visibility.Visible;
noneFound_notification.Show("Failed to request rooms! Server responded:\nType: " + errorMessage.ERROR_OBJ.ERROR_NAME + "\nMessage: " + errorMessage.ERROR_OBJ.ERROR_MESSAGE);
}).AsTask();
return(true);
}
return(false);
}
private bool onMessage(IQMessage msg)
{
if (msg is IQErrorMessage errMsg)
{
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Logger.Warn("Failed to set bookmarks: " + errMsg.ToString());
accountSelection_asc.showErrorMessage("Failed to add bookmark - server error!");
add_pgr.Visibility = Visibility.Collapsed;
add_btn.IsEnabled = true;
}).AsTask();
return(true);
}
if (string.Equals(msg.TYPE, IQMessage.RESULT))
{
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => Hide()).AsTask();
return(true);
}
return(false);
}
private bool onDiscoMsg(MessageResponseHelper <IQMessage> helper, IQMessage msg)
{
if (msg is DiscoResponseMessage response && helper.getMessageSender() is XMPPClient client)
{
switch (response.DISCO_TYPE)
{
case DiscoType.ITEMS:
addItems(response.ITEMS, response.getFrom(), client, true);
break;
case DiscoType.INFO:
addFeatures(response.FEATURES, response.getFrom());
addIdentities(response.IDENTITIES, response.getFrom());
break;
default:
throw new InvalidOperationException("[" + nameof(DiscoDBManager) + "] Unexpected value for DISCO_TYPE: " + response.DISCO_TYPE);
}
}
return(false);
}
private bool onRequestDeviceListStatelessMessage(IQMessage msg)
{
if (msg is OmemoDeviceListResultMessage devMsg)
{
requestDeviceListStatelessOnResult?.Invoke(true, devMsg.DEVICES);
requestDeviceListStatelessOnResult = null;
return(true);
}
else if (msg is IQErrorMessage errMsg)
{
if (errMsg.ERROR_OBJ.ERROR_NAME == ErrorName.ITEM_NOT_FOUND)
{
requestDeviceListStatelessOnResult?.Invoke(true, new OmemoDevices());
}
else
{
requestDeviceListStatelessOnResult?.Invoke(false, null);
}
requestDeviceListStatelessOnResult = null;
return(true);
}
return(false);
}
private bool OnUpdateBookmarksMessage(MessageResponseHelper <IQMessage> helper, IQMessage msg)
{
if (msg is IQErrorMessage errMsg)
{
InvokeOnError("Error", "Failed to bookmark!\nServer responded: " + errMsg.ERROR_OBJ.ERROR_NAME);
return(true);
}
return(string.Equals(msg.TYPE, IQMessage.RESULT));
}
/// <summary>
/// 启用插件
/// </summary>
/// <param name="invoker"></param>
/// <returns></returns>
public static bool EnableInvoker(IQMessage invoker)
{
return(MessageManager.BindInvoker(invoker));
}
/// <summary>
/// 停用插件
/// </summary>
/// <param name="invoker"></param>
/// <returns></returns>
public static bool DisableInvoker(IQMessage invoker)
{
return(MessageManager.UnbindInvoker(invoker));
}
/// <summary>
/// Parses the given messages and invokes the ConnectionNewValidMessage event for each message.
/// </summary>
/// <param name="data">The messages string to parse.</param>
private async Task parseMessageAsync(string data)
{
// Parse message:
List <AbstractMessage> messages = null;
try
{
messages = parser.parseMessages(data);
}
catch (Exception e)
{
Logger.Error("Error during message parsing." + e);
return;
}
// Process messages:
foreach (AbstractMessage msg in messages)
{
// Filter IQ messages which ids are not valid:
if (msg is IQMessage)
{
IQMessage iq = msg as IQMessage;
if (iq.GetType().Equals(IQMessage.RESULT) && messageIdCache.getTimed(iq.ID) != null)
{
Logger.Warn("Invalid message id received!");
return;
}
}
// Invoke message processors:
NewValidMessage?.Invoke(this, new NewValidMessageEventArgs(msg));
// Should restart connection?
if (msg.getRestartConnection() != AbstractMessage.NO_RESTART)
{
if (msg.getRestartConnection() == AbstractMessage.SOFT_RESTART)
{
await softRestartAsync();
}
else if (msg.getRestartConnection() == AbstractMessage.HARD_RESTART)
{
await hardRestartAsync();
}
else
{
throw new ArgumentException("Invalid restart type: " + msg.getRestartConnection());
}
}
// Filter already processed messages:
if (msg.isProcessed())
{
return;
}
// --------------------------------------------------------------------
// Open stream:
if (msg is OpenStreamAnswerMessage)
{
OpenStreamAnswerMessage oA = msg as OpenStreamAnswerMessage;
if (oA.ID == null)
{
// TODO Handle OpenStreamAnswerMessage id == null
//Error throw exception?!
return;
}
streamId = oA.ID;
}
// Close stream message:
else if (msg is CloseStreamMessage)
{
switch (state)
{
case ConnectionState.CONNECTING:
case ConnectionState.CONNECTED:
await internalDisconnectAsync();
break;
}
}
// Rooster:
else if (msg is RosterMessage)
{
NewRoosterMessage?.Invoke(this, new NewValidMessageEventArgs(msg));
}
// Presence:
else if (msg is PresenceMessage && (msg as PresenceMessage).getFrom() != null)
{
NewPresenceMessage?.Invoke(this, new NewValidMessageEventArgs(msg));
}
// Bookmarks:
else if (msg is BookmarksResultMessage)
{
NewBookmarksResultMessage?.Invoke(this, new NewBookmarksResultMessageEventArgs(msg as BookmarksResultMessage));
}
else if (msg is OmemoDeviceListEventMessage deviceListEvent)
{
OMEMO_HELPER.onOmemoDeviceListEventMessage(deviceListEvent);
}
}
}
