//--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\
#region --Set-, Get- Methods--
#endregion
//--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\
#region --Misc Methods (Public)--
#endregion
#region --Misc Methods (Private)--
private bool checkUserInput()
{
client = accountSelection_asc.getSelectedAccount();
if (client is null)
{
accountSelection_asc.showErrorMessage("No account selected!");
return(false);
}
if (client.getXMPPAccount().getBareJid().Equals(jabberId_tbx.Text))
{
accountSelection_asc.showErrorMessage("You can't start a chat with your self!");
return(false);
}
if (!Utils.isBareJid(jabberId_tbx.Text))
{
accountSelection_asc.showErrorMessage("Invalid JabberID!");
return(false);
}
jabberId = jabberId_tbx.Text;
if (ChatDBManager.INSTANCE.doesChatExist(ChatTable.generateId(jabberId, client.getXMPPAccount().getBareJid())))
{
accountSelection_asc.showErrorMessage("Chat does already exist!");
return(false);
}
return(true);
}
private void C_OmemoSessionBuildError(XMPPClient client, XMPP_API.Classes.Events.OmemoSessionBuildErrorEventArgs args)
{
Task.Run(() =>
{
ChatTable chat = ChatDBManager.INSTANCE.getChat(ChatTable.generateId(args.CHAT_JID, client.getXMPPAccount().getBareJid()));
if (!(chat is null))
{
// Add an error chat message:
ChatMessageTable msg = new ChatMessageTable()
{
id = ChatMessageTable.generateErrorMessageId(AbstractMessage.getRandomId(), chat.id),
chatId = chat.id,
date = DateTime.Now,
fromUser = args.CHAT_JID,
isImage = false,
message = "Failed to encrypt and send " + args.MESSAGES.Count + " OMEMO message(s) with:\n" + args.ERROR,
state = MessageState.UNREAD,
type = MessageMessage.TYPE_ERROR
};
ChatDBManager.INSTANCE.setChatMessage(msg, true, false);
// Set chat messages to encrypted failed:
setOmemoChatMessagesSendFailed(args.MESSAGES, chat);
}
});
}
private void C_NewBookmarksResultMessage(XMPPClient client, NewBookmarksResultMessageEventArgs args)
{
foreach (ConferenceItem c in args.BOOKMARKS_MESSAGE.STORAGE.CONFERENCES)
{
bool newMUC = false;
string to = client.getXMPPAccount().getIdAndDomain();
string from = c.jid;
string id = ChatTable.generateId(from, to);
// Create / update chat:
ChatTable chat = ChatDBManager.INSTANCE.getChat(id);
if (chat == null)
{
chat = new ChatTable()
{
id = id,
chatJabberId = from,
userAccountId = to,
ask = null,
lastActive = DateTime.Now,
muted = false,
status = null,
subscription = null
};
newMUC = true;
}
chat.chatType = ChatType.MUC;
chat.inRoster = true;
chat.presence = Presence.Unavailable;
ChatDBManager.INSTANCE.setChat(chat, false, true);
// Create / update MUC info:
MUCChatInfoTable info = MUCDBManager.INSTANCE.getMUCInfo(chat.id);
if (info == null)
{
info = new MUCChatInfoTable
{
chatId = chat.id,
subject = null
};
newMUC = true;
}
info.autoEnterRoom = c.autoJoin;
info.name = c.name;
info.nickname = c.nick;
info.password = c.password;
MUCDBManager.INSTANCE.setMUCChatInfo(info, false, true);
// Enter MUC manually if the MUC is new for this client:
if (newMUC && info.autoEnterRoom && !Settings.getSettingBoolean(SettingsConsts.DISABLE_AUTO_JOIN_MUC))
{
Task.Run(() => MUCHandler.INSTANCE.enterMUCAsync(client, chat, info));
}
}
}
public OmemoFingerprint getFingerprint(SignalProtocolAddress address, string accountId)
{
string chatId = ChatTable.generateId(address.getName(), accountId);
string id = OmemoFingerprintTable.generateId(chatId, address);
List <OmemoFingerprintTable> list = dB.Query <OmemoFingerprintTable>(true, "SELECT * FROM " + DBTableConsts.OMEMO_FINGERPRINT_TABLE + " WHERE id = ?;", id);
return(list.Count <= 0 ? null : list[0].toOmemoFingerprint());
}
public void deleteAllForAccount(string accountId)
{
deleteIdentityKey(accountId);
deletePreKey(accountId);
deleteSignedPreKey(accountId);
deleteSessions(accountId);
deleteFingerprints(ChatTable.generateId(accountId, accountId));
}
public void onMUCRoomSubjectMessage(MUCRoomSubjectMessage mucRoomSubject)
{
string to = Utils.getBareJidFromFullJid(mucRoomSubject.getTo());
string from = Utils.getBareJidFromFullJid(mucRoomSubject.getFrom());
string id = ChatTable.generateId(from, to);
MUCDBManager.INSTANCE.setMUCSubject(id, mucRoomSubject.SUBJECT, true);
}
private void C_NewDeliveryReceipt(XMPPClient client, NewDeliveryReceiptEventArgs args)
{
Task.Run(() =>
{
string to = Utils.getBareJidFromFullJid(args.MSG.getTo());
string from = Utils.getBareJidFromFullJid(args.MSG.getFrom());
string chatId = ChatTable.generateId(from, to);
string msgId = ChatMessageTable.generateId(args.MSG.RECEIPT_ID, chatId);
ChatDBManager.INSTANCE.setMessageAsDeliverd(msgId, true);
});
}
/// <summary>
/// Tries to add the room.
/// </summary>
/// <returns>Returns true if the account got added.</returns>
private bool addRoom()
{
if (checkUserInputAndWarn())
{
XMPPClient client = accountSelection_asc.getSelectedAccount();
string roomJid = roomName_tbx.Text + '@' + server_asbx.Text.ToLower();
ChatTable muc = new ChatTable()
{
id = ChatTable.generateId(roomJid, client.getXMPPAccount().getIdAndDomain()),
ask = null,
chatJabberId = roomJid,
userAccountId = client.getXMPPAccount().getIdAndDomain(),
chatType = ChatType.MUC,
inRoster = (bool)bookmark_cbx.IsChecked,
muted = false,
lastActive = DateTime.Now,
subscription = "none"
};
ChatDBManager.INSTANCE.setChat(muc, false, true);
MUCChatInfoTable info = new MUCChatInfoTable()
{
chatId = muc.id,
subject = null,
state = MUCState.DISCONNECTED,
name = null,
password = null,
nickname = nick_tbx.Text,
autoEnterRoom = (bool)autoJoin_cbx.IsChecked
};
if ((bool)enablePassword_cbx.IsChecked)
{
info.password = password_pwb.Password;
}
MUCDBManager.INSTANCE.setMUCChatInfo(info, false, true);
if (info.autoEnterRoom)
{
Task t = MUCHandler.INSTANCE.enterMUCAsync(client, muc, info);
}
if ((bool)bookmark_cbx.IsChecked)
{
List <ConferenceItem> conferenceItems = MUCDBManager.INSTANCE.getXEP0048ConferenceItemsForAccount(client.getXMPPAccount().getIdAndDomain());
setBookmarkHelper = client.PUB_SUB_COMMAND_HELPER.setBookmars_xep_0048(conferenceItems, onMessage, onTimeout);
}
return(true);
}
return(false);
}
private async Task onMUCErrorMessageAsync(XMPPClient client, MUCErrorMessage errorMessage)
{
string room = Utils.getBareJidFromFullJid(errorMessage.getFrom());
if (room != null)
{
string chatId = ChatTable.generateId(room, client.getXMPPAccount().getBareJid());
ChatTable muc = ChatDBManager.INSTANCE.getChat(chatId);
if (muc != null)
{
MUCChatInfoTable info = MUCDBManager.INSTANCE.getMUCInfo(chatId);
if (info != null)
{
Logger.Error("Received an error message for MUC: " + muc.chatJabberId + "\n" + errorMessage.ERROR_MESSAGE);
stopMUCJoinHelper(muc);
if (info.state != MUCState.DISCONNECTED)
{
await sendMUCLeaveMessageAsync(client, muc, info);
}
switch (errorMessage.ERROR_CODE)
{
// No access - user got baned:
case 403:
MUCDBManager.INSTANCE.setMUCState(info.chatId, MUCState.BANED, true);
addChatInfoMessage(info.chatId, room, "Unable to join room!\nYou are baned from this room.");
return;
default:
MUCDBManager.INSTANCE.setMUCState(info.chatId, MUCState.ERROR, true);
break;
}
// Add an error chat message:
ChatMessageTable msg = new ChatMessageTable()
{
id = ChatMessageTable.generateErrorMessageId(errorMessage.ID ?? AbstractMessage.getRandomId(), muc.id),
chatId = muc.id,
date = DateTime.Now,
fromUser = errorMessage.getFrom(),
isImage = false,
message = "Code: " + errorMessage.ERROR_CODE + "\nType: " + errorMessage.ERROR_TYPE + "\nMessage:\n" + errorMessage.ERROR_MESSAGE,
state = MessageState.UNREAD,
type = MessageMessage.TYPE_ERROR
};
ChatDBManager.INSTANCE.setChatMessage(msg, true, false);
}
}
}
}
private void C_NewPresence(XMPPClient client, XMPP_API.Classes.Events.NewPresenceMessageEventArgs args)
{
string from = Utils.getBareJidFromFullJid(args.PRESENCE_MESSAGE.getFrom());
// If received a presence message from your own account, ignore it:
if (string.Equals(from, client.getXMPPAccount().getIdAndDomain()))
{
return;
}
string to = client.getXMPPAccount().getIdAndDomain();
string id = ChatTable.generateId(from, to);
ChatTable chat = ChatDBManager.INSTANCE.getChat(id);
switch (args.PRESENCE_MESSAGE.TYPE)
{
case "subscribe":
case "unsubscribed":
if (chat == null)
{
chat = new ChatTable
{
id = id,
chatJabberId = from,
userAccountId = to,
inRoster = false,
muted = false,
lastActive = DateTime.Now,
ask = null,
status = null,
chatState = null
};
}
chat.subscription = args.PRESENCE_MESSAGE.TYPE;
break;
default:
break;
}
if (chat != null)
{
chat.status = args.PRESENCE_MESSAGE.STATUS;
chat.presence = args.PRESENCE_MESSAGE.PRESENCE;
ChatDBManager.INSTANCE.setChat(chat, false, true);
}
else
{
Logger.Warn("Received a presence message for an unknown chat from: " + from + ", to: " + to);
}
}
/// <summary>
/// Checks if the fingerprint is trusted by the following mechanism:
/// 1. Does a chat exist for the fingerprint? Yes -> 2. No. -> false
/// 2. Is "trusted keys only" activated for chats? Yes -> 3. No -> true
/// 3. Is the key trusted? Yes -> true No -> false
/// </summary>
/// <param name="fingerprint">The fingerprint we want to check if it's valid.</param>
public bool IsFingerprintTrusted(OmemoFingerprint fingerprint)
{
// Check for own devices:
if (string.Equals(fingerprint.ADDRESS.getName(), ACCOUNT.getBareJid()))
{
// No trust management for own devices right now.
return(true);
}
// Check for contact devices:
else
{
string chatId = ChatTable.generateId(fingerprint.ADDRESS.getName(), ACCOUNT.getBareJid());
ChatTable chat = ChatDBManager.INSTANCE.getChat(chatId);
return(!(chat is null) && (!chat.omemoTrustedKeysOnly || fingerprint.trusted));
}
}
private async void Client_NewChatState(XMPPClient client, XMPP_API.Classes.Network.Events.NewChatStateEventArgs args)
{
if (args.Cancel)
{
return;
}
string chatId = ChatTable.generateId(args.FROM, args.TO);
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (Chat != null && Chat.chatType == ChatType.CHAT && string.Equals(chatId, Chat.id))
{
storeChatState(args.STATE);
args.Cancel = true;
}
});
}
private async void C_NewPresence(XMPPClient client, XMPP_API.Classes.Events.NewPresenceMessageEventArgs args)
{
string from = Utils.getBareJidFromFullJid(args.PRESENCE_MESSAGE.getFrom());
// If received a presence message from your own account, ignore it:
if (string.Equals(from, client.getXMPPAccount().getBareJid()))
{
return;
}
string to = client.getXMPPAccount().getBareJid();
string id = ChatTable.generateId(from, to);
ChatTable chat = ChatDBManager.INSTANCE.getChat(id);
switch (args.PRESENCE_MESSAGE.TYPE)
{
case "subscribe":
case "unsubscribed":
if (chat is null)
{
chat = new ChatTable(from, to);
}
chat.subscription = args.PRESENCE_MESSAGE.TYPE;
break;
// Answer presence probes:
case "probe":
await answerPresenceProbeAsync(from, to, chat, client, args.PRESENCE_MESSAGE);
return;
default:
break;
}
if (chat != null)
{
chat.status = args.PRESENCE_MESSAGE.STATUS;
chat.presence = args.PRESENCE_MESSAGE.PRESENCE;
ChatDBManager.INSTANCE.setChat(chat, false, true);
}
else
{
Logger.Warn("Received a presence message for an unknown chat from: " + from + ", to: " + to);
}
}
/// <summary>
/// Checks if the user input is valid.
/// </summary>
/// <returns>Returns whether the user input is valid.</returns>
private bool checkUserInputAndWarn()
{
XMPPClient client = accountSelection_asc.getSelectedAccount();
if (client == null)
{
accountSelection_asc.showErrorMessage("No account selected!");
return(false);
}
if (!client.isConnected())
{
accountSelection_asc.showErrorMessage("Account not connected!");
return(false);
}
if (string.IsNullOrWhiteSpace(nick_tbx.Text))
{
accountSelection_asc.showErrorMessage("No nickname given!");
return(false);
}
if (string.IsNullOrWhiteSpace(roomName_tbx.Text))
{
accountSelection_asc.showErrorMessage("No room name given!");
return(false);
}
if (!Utils.isValidServerAddress(server_asbx.Text))
{
accountSelection_asc.showErrorMessage("Invalid server!");
return(false);
}
string roomJid = roomName_tbx.Text + '@' + server_asbx.Text;
if (ChatDBManager.INSTANCE.doesChatExist(ChatTable.generateId(roomJid, client.getXMPPAccount().getIdAndDomain())))
{
accountSelection_asc.showErrorMessage("Chat already exists!");
return(false);
}
accountSelection_asc.hideErrorMessage();
return(true);
}
/// <summary>
/// Adds and starts a new chat.
/// </summary>
/// <param name="client">Which account/client owns this chat?</param>
/// <param name="bareJid">The bare JID of the opponent.</param>
/// <param name="addToRoster">Should the chat get added to the users roster?</param>
/// <param name="requestSubscription">Request a presence subscription?</param>
private async Task AddChatAsync(XMPPClient client, string bareJid, bool addToRoster, bool requestSubscription)
{
if (client is null || string.IsNullOrEmpty(bareJid))
{
Logger.Error("Unable to add chat! client ?= " + (client is null) + " bareJid ?=" + (bareJid is null));
return;
}
await Task.Run(async() =>
{
ChatTable chat = ChatDBManager.INSTANCE.getChat(ChatTable.generateId(bareJid, client.getXMPPAccount().getBareJid()));
if (chat is null)
{
chat = new ChatTable(bareJid, client.getXMPPAccount().getBareJid());
}
// Set chat active:
chat.isChatActive = true;
chat.lastActive = DateTime.Now;
// Add to roster:
if (addToRoster && !chat.inRoster)
{
await client.GENERAL_COMMAND_HELPER.addToRosterAsync(bareJid);
chat.inRoster = true;
}
// Request presence subscription:
if (requestSubscription && (string.Equals(chat.subscription, "none") || string.Equals(chat.subscription, "from")) && string.IsNullOrEmpty(chat.subscription))
{
await client.GENERAL_COMMAND_HELPER.requestPresenceSubscriptionAsync(bareJid);
chat.subscription = "pending";
}
ChatDBManager.INSTANCE.setChat(chat, false, true);
});
}
/// <summary>
/// Adds a new chat to the chatsList and the DB.
/// </summary>
/// <param name="client">Which account/client owns this chat?</param>
/// <param name="jID">The JID if the new chat.</param>
/// <param name="addToRoster">Should the chat get added to the users roster?</param>
/// <param name="requestSubscription">Request a presence subscription?</param>
private async Task addChatAsync(XMPPClient client, string jID, bool addToRoster, bool requestSubscription)
{
if (client == null || jID == null)
{
string errorMessage = "Unable to add chat! client ?= " + (client == null) + " jabberId ?=" + (jID == null);
Logger.Error(errorMessage);
MessageDialog messageDialog = new MessageDialog("Error")
{
Content = errorMessage
};
await messageDialog.ShowAsync();
}
else
{
if (addToRoster)
{
await client.addToRosterAsync(jID);
}
if (requestSubscription)
{
await client.requestPresenceSubscriptionAsync(jID);
}
ChatDBManager.INSTANCE.setChat(new ChatTable()
{
id = ChatTable.generateId(jID, client.getXMPPAccount().getIdAndDomain()),
chatJabberId = jID,
userAccountId = client.getXMPPAccount().getIdAndDomain(),
ask = null,
inRoster = addToRoster,
lastActive = DateTime.Now,
muted = false,
presence = Presence.Unavailable,
status = null,
subscription = requestSubscription ? "pending" : null
}, false, true);
}
}
private async void C_NewChatMessage(XMPPClient client, XMPP_API.Classes.Network.Events.NewChatMessageEventArgs args)
{
MessageMessage msg = args.getMessage();
// Handel MUC room subject messages:
if (msg is MUCRoomSubjectMessage)
{
MUCHandler.INSTANCE.onMUCRoomSubjectMessage(msg as MUCRoomSubjectMessage);
return;
}
string from = Utils.getBareJidFromFullJid(msg.getFrom());
string to = Utils.getBareJidFromFullJid(msg.getTo());
string id;
if (msg.CC_TYPE == CarbonCopyType.SENT)
{
id = ChatTable.generateId(to, from);
}
else
{
id = ChatTable.generateId(from, to);
}
// Check if device id is valid and if, decrypt the OMEMO messages:
if (msg is OmemoMessageMessage omemoMessage)
{
OmemoHelper helper = client.getOmemoHelper();
if (helper is null)
{
C_OmemoSessionBuildError(client, new OmemoSessionBuildErrorEventArgs(id, OmemoSessionBuildError.KEY_ERROR, new List <OmemoMessageMessage> {
omemoMessage
}));
Logger.Error("Failed to decrypt OMEMO message - OmemoHelper is null");
return;
}
else if (!client.getXMPPAccount().checkOmemoKeys())
{
C_OmemoSessionBuildError(client, new OmemoSessionBuildErrorEventArgs(id, OmemoSessionBuildError.KEY_ERROR, new List <OmemoMessageMessage> {
omemoMessage
}));
Logger.Error("Failed to decrypt OMEMO message - keys are corrupted");
return;
}
else if (!await omemoMessage.decryptAsync(client.getOmemoHelper(), client.getXMPPAccount().omemoDeviceId))
{
return;
}
}
ChatTable chat = ChatDBManager.INSTANCE.getChat(id);
bool chatChanged = false;
// Spam detection:
if (Settings.getSettingBoolean(SettingsConsts.SPAM_DETECTION_ENABLED))
{
if (Settings.getSettingBoolean(SettingsConsts.SPAM_DETECTION_FOR_ALL_CHAT_MESSAGES) || chat is null)
{
if (SpamDBManager.INSTANCE.isSpam(msg.MESSAGE))
{
Logger.Warn("Received spam message from " + from);
return;
}
}
}
if (chat is null)
{
chatChanged = true;
chat = new ChatTable(from, to)
{
lastActive = msg.getDelay(),
chatType = string.Equals(msg.TYPE, MessageMessage.TYPE_GROUPCHAT) ? ChatType.MUC : ChatType.CHAT
};
}
ChatMessageTable message = new ChatMessageTable(msg, chat);
// Handle MUC invite messages:
if (msg is DirectMUCInvitationMessage)
{
DirectMUCInvitationMessage inviteMessage = msg as DirectMUCInvitationMessage;
bool doesRoomExist = ChatDBManager.INSTANCE.doesMUCExist(ChatTable.generateId(inviteMessage.ROOM_JID, msg.getTo()));
bool doesOutstandingInviteExist = ChatDBManager.INSTANCE.doesOutstandingMUCInviteExist(id, inviteMessage.ROOM_JID);
if (doesRoomExist && doesOutstandingInviteExist)
{
return;
}
MUCDirectInvitationTable inviteTable = new MUCDirectInvitationTable(inviteMessage, message.id);
ChatDBManager.INSTANCE.setMUCDirectInvitation(inviteTable);
}
bool isMUCMessage = string.Equals(MessageMessage.TYPE_GROUPCHAT, message.type);
ChatMessageTable existingMessage = ChatDBManager.INSTANCE.getChatMessageById(message.id);
bool doesMessageExist = existingMessage != null;
if (isMUCMessage)
{
MUCChatInfoTable mucInfo = MUCDBManager.INSTANCE.getMUCInfo(chat.id);
if (mucInfo != null)
{
if (Equals(message.fromUser, mucInfo.nickname))
{
// Filter MUC messages that already exist:
// ToDo: Allow MUC messages being edited and detect it
if (doesMessageExist)
{
return;
}
else
{
message.state = MessageState.SEND;
}
}
else
{
if (doesMessageExist)
{
message.state = existingMessage.state;
}
}
}
}
if (chat.lastActive.CompareTo(msg.getDelay()) < 0)
{
chatChanged = true;
chat.lastActive = msg.getDelay();
}
if (chatChanged)
{
ChatDBManager.INSTANCE.setChat(chat, false, true);
}
// Send XEP-0184 (Message Delivery Receipts) reply:
if (msg.RECIPT_REQUESTED && id != null && !Settings.getSettingBoolean(SettingsConsts.DONT_SEND_CHAT_MESSAGE_RECEIVED_MARKERS))
{
await Task.Run(async() =>
{
DeliveryReceiptMessage receiptMessage = new DeliveryReceiptMessage(client.getXMPPAccount().getFullJid(), from, msg.ID);
await client.sendAsync(receiptMessage);
});
}
ChatDBManager.INSTANCE.setChatMessage(message, !doesMessageExist, doesMessageExist && !isMUCMessage);
// Show toast:
if (!doesMessageExist && !chat.muted)
{
await Task.Run(() =>
{
try
{
switch (msg.TYPE)
{
case MessageMessage.TYPE_GROUPCHAT:
case MessageMessage.TYPE_CHAT:
if (!message.isCC)
{
if (message.isImage)
{
ToastHelper.showChatTextImageToast(message, chat);
}
else
{
ToastHelper.showChatTextToast(message, chat);
}
}
break;
default:
break;
}
}
catch (Exception e)
{
Logger.Error("Failed to send toast notification!", e);
}
});
}
}
private void C_NewRoosterMessage(IMessageSender sender, NewValidMessageEventArgs args)
{
if (args.MESSAGE is RosterResultMessage msg && sender is XMPPClient client)
{
string to = client.getXMPPAccount().getBareJid();
string type = msg.TYPE;
if (string.Equals(type, IQMessage.RESULT))
{
ChatDBManager.INSTANCE.setAllNotInRoster(client.getXMPPAccount().getBareJid());
}
else if (!string.Equals(type, IQMessage.SET))
{
// No roster result or set => return
return;
}
foreach (RosterItem item in msg.ITEMS)
{
string from = item.JID;
string id = ChatTable.generateId(from, to);
ChatTable chat = ChatDBManager.INSTANCE.getChat(id);
if (chat != null)
{
chat.inRoster = !string.Equals(item.SUBSCRIPTION, "remove");
}
else if (!string.Equals(item.SUBSCRIPTION, "remove"))
{
chat = new ChatTable(from, to)
{
inRoster = true,
chatType = ChatType.CHAT
};
}
else
{
continue;
}
// Only update the subscription state, if not set to subscribe:
if (!string.Equals(chat.subscription, "subscribe"))
{
chat.subscription = item.SUBSCRIPTION;
}
chat.subscriptionRequested = string.Equals(item.ASK, "subscribe");
switch (chat.subscription)
{
case "unsubscribe":
case "from":
case "none":
case "pending":
case null:
chat.presence = Presence.Unavailable;
break;
default:
break;
}
ChatDBManager.INSTANCE.setChat(chat, false, true);
}
}
}
private void C_NewRoosterMessage(IMessageSender sender, NewValidMessageEventArgs args)
{
XMPPClient client = sender as XMPPClient;
if (args.MESSAGE is RosterMessage)
{
RosterMessage msg = args.MESSAGE as RosterMessage;
string to = client.getXMPPAccount().getIdAndDomain();
string type = msg.TYPE;
if (string.Equals(type, IQMessage.RESULT))
{
ChatDBManager.INSTANCE.setAllNotInRoster(client.getXMPPAccount().getIdAndDomain());
}
else if (type == null || !string.Equals(type, IQMessage.SET))
{
// No roster result or set => return
return;
}
foreach (RosterItem item in msg.ITEMS)
{
string from = item.JID;
string id = ChatTable.generateId(from, to);
ChatTable chat = ChatDBManager.INSTANCE.getChat(id);
if (chat != null)
{
chat.subscription = item.SUBSCRIPTION;
chat.inRoster = !item.SUBSCRIPTION.Equals("remove");
chat.ask = item.ASK;
}
else if (!Equals(item.SUBSCRIPTION, "remove"))
{
chat = new ChatTable()
{
id = id,
chatJabberId = from,
userAccountId = to,
subscription = item.SUBSCRIPTION,
lastActive = DateTime.Now,
muted = false,
inRoster = true,
ask = item.ASK,
chatType = ChatType.CHAT
};
}
else
{
continue;
}
switch (chat.subscription)
{
case "unsubscribe":
case "from":
case "none":
case "pending":
case null:
chat.presence = Presence.Unavailable;
break;
default:
break;
}
ChatDBManager.INSTANCE.setChat(chat, false, true);
}
}
}
//--------------------------------------------------------Events:---------------------------------------------------------------------\\
#region --Events--
private void C_NewMUCMemberPresenceMessage(XMPPClient client, XMPP_API.Classes.Network.Events.NewMUCMemberPresenceMessageEventArgs args)
{
Task.Run(() =>
{
MUCMemberPresenceMessage msg = args.mucMemberPresenceMessage;
string roomJid = Utils.getBareJidFromFullJid(msg.getFrom());
if (roomJid is null)
{
return;
}
string chatId = ChatTable.generateId(roomJid, client.getXMPPAccount().getBareJid());
MUCOccupantTable member = MUCDBManager.INSTANCE.getMUCOccupant(chatId, msg.FROM_NICKNAME);
if (member is null)
{
member = new MUCOccupantTable
{
id = MUCOccupantTable.generateId(chatId, msg.FROM_NICKNAME),
nickname = msg.FROM_NICKNAME,
chatId = chatId
};
}
member.affiliation = msg.AFFILIATION;
member.role = msg.ROLE;
member.jid = msg.JID;
bool isUnavailable = Equals(msg.TYPE, "unavailable");
if (isUnavailable)
{
if (msg.STATUS_CODES.Contains(MUCPresenceStatusCode.PRESENCE_SELFE_REFERENCE))
{
// Nickname got changed by user or room:
if (msg.STATUS_CODES.Contains(MUCPresenceStatusCode.MEMBER_NICK_CHANGED) || msg.STATUS_CODES.Contains(MUCPresenceStatusCode.ROOM_NICK_CHANGED))
{
// Update MUC info:
MUCDBManager.INSTANCE.setMUCInfoNickname(chatId, msg.NICKNAME, true);
// Add new member:
MUCDBManager.INSTANCE.setMUCOccupant(new MUCOccupantTable
{
id = MUCOccupantTable.generateId(chatId, msg.NICKNAME),
nickname = msg.NICKNAME,
chatId = member.chatId,
affiliation = member.affiliation,
role = member.role,
jid = member.jid,
}, false, true);
}
// Occupant got kicked:
else if (msg.STATUS_CODES.Contains(MUCPresenceStatusCode.MEMBER_GOT_KICKED))
{
// Update MUC state:
MUCDBManager.INSTANCE.setMUCState(chatId, MUCState.KICKED, true);
}
else if (msg.STATUS_CODES.Contains(MUCPresenceStatusCode.MEMBER_GOT_BANED))
{
// Update MUC state:
MUCDBManager.INSTANCE.setMUCState(chatId, MUCState.BANED, true);
}
else
{
// Update MUC state:
MUCDBManager.INSTANCE.setMUCState(chatId, MUCState.DISCONNECTED, true);
}
}
if (msg.STATUS_CODES.Contains(MUCPresenceStatusCode.MEMBER_GOT_KICKED))
{
// Add kicked chat message:
addOccupantKickedMessage(chatId, roomJid, member.nickname);
}
if (msg.STATUS_CODES.Contains(MUCPresenceStatusCode.MEMBER_GOT_BANED))
{
// Add baned chat message:
addOccupantBanedMessage(chatId, roomJid, member.nickname);
}
}
// If the type equals 'unavailable', a user left the room:
MUCDBManager.INSTANCE.setMUCOccupant(member, isUnavailable, true);
});
}
public IEnumerable <OmemoFingerprint> LoadFingerprints(string bareJid)
{
string chat = ChatTable.generateId(bareJid, ACCOUNT.getBareJid());
return(OmemoSignalKeyDBManager.INSTANCE.getFingerprints(chat));
}
private void C_NewChatMessage(XMPPClient client, XMPP_API.Classes.Network.Events.NewChatMessageEventArgs args)
{
MessageMessage msg = args.getMessage();
// Handel MUC room subject messages:
if (msg is MUCRoomSubjectMessage)
{
MUCHandler.INSTANCE.onMUCRoomSubjectMessage(msg as MUCRoomSubjectMessage);
return;
}
string from = Utils.getBareJidFromFullJid(msg.getFrom());
// Check if device id is valid and if, decrypt the OMEMO messages:
if (msg is OmemoMessageMessage omemoMessage)
{
// Decryption failed:
if (!omemoMessage.decrypt(client.getOmemoHelper(), client.getXMPPAccount().omemoDeviceId))
{
return;
}
}
string to = Utils.getBareJidFromFullJid(msg.getTo());
string id;
if (msg.CC_TYPE == CarbonCopyType.SENT)
{
id = ChatTable.generateId(to, from);
}
else
{
id = ChatTable.generateId(from, to);
}
ChatTable chat = ChatDBManager.INSTANCE.getChat(id);
bool chatChanged = false;
if (chat == null)
{
chatChanged = true;
chat = new ChatTable()
{
id = id,
chatJabberId = from,
userAccountId = to,
ask = null,
inRoster = false,
lastActive = msg.getDelay(),
muted = false,
presence = Presence.Unavailable,
status = null,
subscription = null,
chatType = Equals(msg.TYPE, MessageMessage.TYPE_GROUPCHAT) ? ChatType.MUC : ChatType.CHAT,
};
}
ChatMessageTable message = new ChatMessageTable(msg, chat);
// Handle MUC invite messages:
if (msg is DirectMUCInvitationMessage)
{
DirectMUCInvitationMessage inviteMessage = msg as DirectMUCInvitationMessage;
bool doesRoomExist = ChatDBManager.INSTANCE.doesMUCExist(ChatTable.generateId(inviteMessage.ROOM_JID, msg.getTo()));
bool doesOutstandingInviteExist = ChatDBManager.INSTANCE.doesOutstandingMUCInviteExist(id, inviteMessage.ROOM_JID);
if (doesRoomExist && doesOutstandingInviteExist)
{
return;
}
MUCDirectInvitationTable inviteTable = new MUCDirectInvitationTable(inviteMessage, message.id);
ChatDBManager.INSTANCE.setMUCDirectInvitation(inviteTable);
}
bool isMUCMessage = string.Equals(MessageMessage.TYPE_GROUPCHAT, message.type);
ChatMessageTable existingMessage = ChatDBManager.INSTANCE.getChatMessageById(message.id);
bool doesMessageExist = existingMessage != null;
if (isMUCMessage)
{
MUCChatInfoTable mucInfo = MUCDBManager.INSTANCE.getMUCInfo(chat.id);
if (mucInfo != null)
{
if (Equals(message.fromUser, mucInfo.nickname))
{
// Filter MUC messages that already exist:
// ToDo: Allow MUC messages being edited and detect it
if (doesMessageExist)
{
return;
}
else
{
message.state = MessageState.SEND;
}
}
else
{
if (doesMessageExist)
{
message.state = existingMessage.state;
}
}
}
}
if (chat.lastActive.CompareTo(msg.getDelay()) < 0)
{
chatChanged = true;
chat.lastActive = msg.getDelay();
}
if (chatChanged)
{
ChatDBManager.INSTANCE.setChat(chat, false, true);
}
// Send XEP-0184 (Message Delivery Receipts) reply:
if (msg.RECIPT_REQUESTED && id != null && !Settings.getSettingBoolean(SettingsConsts.DONT_SEND_CHAT_MESSAGE_RECEIVED_MARKERS))
{
Task.Run(async() =>
{
DeliveryReceiptMessage receiptMessage = new DeliveryReceiptMessage(client.getXMPPAccount().getIdDomainAndResource(), from, msg.ID);
await client.sendAsync(receiptMessage, true);
});
}
ChatDBManager.INSTANCE.setChatMessage(message, !doesMessageExist, doesMessageExist && !isMUCMessage);
// Show toast:
if (!doesMessageExist && !chat.muted)
{
Task.Run(() =>
{
try
{
if (!msg.toasted)
{
switch (msg.TYPE)
{
case MessageMessage.TYPE_GROUPCHAT:
case MessageMessage.TYPE_CHAT:
if (!message.isCC)
{
if (message.isEncrypted)
{
ToastHelper.showChatTextEncryptedToast(message, chat);
}
else if (message.isImage)
{
ToastHelper.showChatTextImageToast(message, chat);
}
else
{
ToastHelper.showChatTextToast(message, chat);
}
}
break;
default:
break;
}
msg.setToasted();
}
}
catch (Exception e)
{
Logger.Error("Failed to send toast notification!", e);
}
});
}
}
public void setFingerprint(OmemoFingerprint fingerprint, string accountId)
{
string chatId = ChatTable.generateId(fingerprint.ADDRESS.getName(), accountId);
dB.InsertOrReplace(new OmemoFingerprintTable(fingerprint, chatId));
}