private bool onChangeNickMessage(PresenceMessage msg)
{
if (msg is MUCMemberPresenceMessage)
{
// Success:
MUCMemberPresenceMessage mPMessage = msg as MUCMemberPresenceMessage;
if (mPMessage.STATUS_CODES.Contains(MUCPresenceStatusCode.PRESENCE_SELFE_REFERENCE) && (mPMessage.STATUS_CODES.Contains(MUCPresenceStatusCode.MEMBER_NICK_CHANGED) || mPMessage.STATUS_CODES.Contains(MUCPresenceStatusCode.ROOM_NICK_CHANGED)))
{
Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
MUCInfo.nickname = mPMessage.NICKNAME;
MUCChatInfoTable info = MUCInfo;
Task.Run(() => MUCDBManager.INSTANCE.setMUCChatInfo(info, false, false));
nickname_stbx.Text = mPMessage.NICKNAME;
nickname_stbx.onSavingDone();
notificationBanner_ian.Show("Successfully changed nickname to: " + mPMessage.NICKNAME, 5000);
}).AsTask();
return(true);
}
}
// Error:
else if (msg is MUCErrorMessage && Equals(msg.ID, changeNickHelper.sendId))
{
MUCErrorMessage errorMessage = msg as MUCErrorMessage;
Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
nickname_stbx.Text = MUCInfo.nickname;
nickname_stbx.onSavingDone();
notificationBanner_ian.Show("Changing nickname failed:\nCode: " + errorMessage.ERROR_CODE + "\nType: " + errorMessage.ERROR_TYPE + "\nMessage:\n" + errorMessage.ERROR_MESSAGE);
}).AsTask();
}
return(false);
}
private void updateNick()
{
nickname_stbx.onStartSaving();
if (string.IsNullOrEmpty(nickname_stbx.Text))
{
notificationBanner_ian.Show("Invalid nickname!");
nickname_stbx.onSavingDone();
return;
}
notificationBanner_ian.Dismiss();
if (isMUCEntered())
{
changeNickHelper = Client.MUC_COMMAND_HELPER.changeNickname(Chat.chatJabberId, nickname_stbx.Text, onChangeNickMessage, onChangeNickTimeout);
}
else
{
MUCInfo.nickname = nickname_stbx.Text;
MUCChatInfoTable info = MUCInfo;
Task.Run(() => MUCDBManager.INSTANCE.setMUCChatInfo(info, false, false));
nickname_stbx.onSavingDone();
}
}
/// <summary>
/// Updates the nickname in the local DB.
/// Also updates bookmarks if any exist.
/// </summary>
/// <returns>Returns true on success.</returns>
public async Task <bool> SaveAsync(ChatTable chat, MUCChatInfoTable mucInfo, XMPPClient client)
{
MODEL.IsSaving = true;
bool success = await Task.Run(async() =>
{
mucInfo.nickname = MODEL.Nickname;
// Try to update the nickname at the chat room:
bool result = await UpdateNicknameAsync(chat, mucInfo, client);
if (!result)
{
return(false);
}
// Update the DB entry since the server could respond with a different nickname:
MUCDBManager.INSTANCE.setMUCChatInfo(mucInfo, false, true);
// Update bookmarks:
return(chat.inRoster ? await UpdateBookmarksAsync(chat, client) : true);
});
MODEL.IsSaving = false;
MODEL.Error = !success;
if (success)
{
Logger.Info("Updating nickname to \"" + MODEL.Nickname + "\" in chat \"" + MODEL.MucName + "\" was successful!");
}
else
{
Logger.Info("Updating nickname to \"" + MODEL.Nickname + "\" in chat \"" + MODEL.MucName + "\" failed!");
}
return(success);
}
public bool UpdateMUCInfo(MUCChatInfoTable mucInfo)
{
lock (SyncRoot)
{
return(CHATS.UpdateMUCInfo(mucInfo));
}
}
private void enterAllMUCs(XMPPClient client)
{
Task.Run(async() =>
{
// Delay joining MUCs for a couple of seconds to prevent a message overload:
if (!await delayAsync(client.getXMPPAccount().getBareJid()))
{
// Delay has been canceled:
return;
}
foreach (ChatTable muc in ChatDBManager.INSTANCE.getAllMUCs(client.getXMPPAccount().getBareJid()))
{
MUCChatInfoTable info = MUCDBManager.INSTANCE.getMUCInfo(muc.id);
if (info is null)
{
info = new MUCChatInfoTable()
{
chatId = muc.id,
state = MUCState.DISCONNECTED,
nickname = muc.userAccountId,
autoEnterRoom = true
};
MUCDBManager.INSTANCE.setMUCChatInfo(info, false, true);
}
if (info.autoEnterRoom)
{
await enterMUCAsync(client, muc, info);
}
}
});
}
private void enterAllMUCs(XMPPClient client)
{
Task.Run(async() =>
{
foreach (ChatTable muc in ChatDBManager.INSTANCE.getAllMUCs(client.getXMPPAccount().getBareJid()))
{
MUCChatInfoTable info = MUCDBManager.INSTANCE.getMUCInfo(muc.id);
if (info is null)
{
info = new MUCChatInfoTable()
{
chatId = muc.id,
state = MUCState.DISCONNECTED,
nickname = muc.userAccountId,
autoEnterRoom = true
};
MUCDBManager.INSTANCE.setMUCChatInfo(info, false, true);
}
if (info.autoEnterRoom)
{
await enterMUCAsync(client, muc, info);
}
}
});
}
private async Task <bool> UpdateNicknameAsync(ChatTable chat, MUCChatInfoTable mucInfo, XMPPClient client)
{
MessageResponseHelperResult <MUCMemberPresenceMessage> result = await client.MUC_COMMAND_HELPER.changeNicknameAsync(chat.chatJabberId, mucInfo.nickname);
if (!string.IsNullOrEmpty(result.RESULT.ERROR_TYPE))
{
Logger.Warn("Failed to change nickname for room \"" + chat.chatJabberId + "\" to \"" + mucInfo.nickname + "\" with: " + result.RESULT.ERROR_MESSAGE);
return(false);
}
// Nickname has been updated successfully:
else if (result.RESULT.STATUS_CODES.Contains(MUCPresenceStatusCode.MEMBER_NICK_CHANGED))
{
return(true);
}
// The room has change the nickname:
else if (result.RESULT.STATUS_CODES.Contains(MUCPresenceStatusCode.ROOM_NICK_CHANGED))
{
if (!Utils.isFullJid(result.RESULT.JID))
{
Logger.Error("Expected a full JID as a MUC nickname changed message with status code 210, but received: " + result.RESULT.JID);
return(false);
}
mucInfo.nickname = Utils.getJidResourcePart(result.RESULT.JID);
return(true);
}
// Should not happen:
Logger.Error("Unknown MUC member presence status code combination received. This should not happen!");
return(false);
}
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 async Task enterMUCAsync(XMPPClient client, ChatTable muc, MUCChatInfoTable info)
{
MUCJoinHelper helper = new MUCJoinHelper(client, muc, info);
TIMED_LIST.addTimed(helper);
await helper.enterRoomAsync();
}
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\
#region --Constructors--
public ChangeNicknameDialog(ChatTable chat, MUCChatInfoTable mucInfo, XMPPClient client)
{
CHAT = chat;
MUC_INFO = mucInfo;
CLIENT = client;
VIEW_MODEL.UpdateView(chat, mucInfo);
InitializeComponent();
}
public ChatTemplate(XMPPClient client, ChatTable chat, MUCChatInfoTable mucInfo, BitmapImage image)
{
this._client = client;
this._chat = chat;
this._mucInfo = mucInfo;
this._image = image;
this.index = -1;
}
public async Task leaveRoomAsync(XMPPClient client, ChatTable muc, MUCChatInfoTable info)
{
stopMUCJoinHelper(muc);
MUCDBManager.INSTANCE.setMUCState(info.chatId, MUCState.DISCONNECTING, true);
await sendMUCLeaveMessageAsync(client, muc, info);
MUCDBManager.INSTANCE.setMUCState(info.chatId, MUCState.DISCONNECTED, true);
}
private void onMUCInfoChanged(string chatId)
{
MUCChatInfoTable info = getMUCInfo(chatId);
if (info != null)
{
MUCInfoChanged?.Invoke(this, new MUCInfoChangedEventArgs(info, false));
}
}
private async void INSTANCE_MUCInfoChanged(MUCDBManager handler, MUCInfoChangedEventArgs args)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (Chat != null && Chat.id.Equals(args.MUC_INFO.chatId))
{
MUCInfo = args.MUC_INFO;
}
});
}
private void savePassword()
{
password_spwbx.onStartSaving();
notificationBanner_ian.Dismiss();
MUCInfo.password = password_spwbx.Password;
MUCChatInfoTable info = MUCInfo;
Task.Run(() => MUCDBManager.INSTANCE.setMUCChatInfo(info, false, true));
password_spwbx.onSavingDone();
notificationBanner_ian.Show("Successfully saved password!", 5000);
}
/// <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 UpdateView(MUCChatInfoTable mucInfo)
{
MODEL.MucSubject = mucInfo.subject;
MODEL.MucState = mucInfo.state;
MODEL.EnterMucAvailable = mucInfo.state != MUCState.ENTERD && mucInfo.state != MUCState.ENTERING;
MODEL.AutoJoin = mucInfo.autoEnterRoom;
MODEL.Nickname = mucInfo.nickname;
if (!string.IsNullOrEmpty(mucInfo.name))
{
MODEL.MucName = mucInfo.name;
MODEL.DifferentMucName = !string.Equals(MODEL.ChatBareJid, MODEL.MucName);
}
}
private async Task AddMucAsync(XMPPClient client, string roomBareJid, string nickname, string password, bool bookmark, bool autoJoin)
{
ChatTable muc = new ChatTable(roomBareJid, client.getXMPPAccount().getBareJid())
{
chatType = ChatType.MUC,
inRoster = bookmark,
subscription = "none",
isChatActive = true
};
MUCChatInfoTable info = new MUCChatInfoTable()
{
chatId = muc.id,
subject = null,
state = MUCState.DISCONNECTED,
name = null,
password = string.IsNullOrEmpty(password) ? null : password,
nickname = nickname,
autoEnterRoom = autoJoin,
};
await Task.Run(() =>
{
ChatDBManager.INSTANCE.setChat(muc, false, true);
MUCDBManager.INSTANCE.setMUCChatInfo(info, false, true);
});
if (info.autoEnterRoom)
{
await MUCHandler.INSTANCE.enterMUCAsync(client, muc, info);
}
if (bookmark)
{
List <ConferenceItem> conferenceItems = MUCDBManager.INSTANCE.getXEP0048ConferenceItemsForAccount(client.getXMPPAccount().getBareJid());
MessageResponseHelperResult <IQMessage> result = await client.PUB_SUB_COMMAND_HELPER.setBookmars_xep_0048Async(conferenceItems);
if (result.STATE == MessageResponseHelperResultState.SUCCESS)
{
if (result.RESULT is IQErrorMessage errMsg)
{
Logger.Warn("Failed to set bookmarks: " + errMsg.ToString());
}
}
else
{
Logger.Warn("Failed to set bookmarks: " + result.STATE);
}
}
}
public async Task ToggleMucAutoJoinAsync(MUCChatInfoTable mucInfo)
{
if (mucInfo is null)
{
return;
}
await Task.Run(() =>
{
mucInfo.autoEnterRoom = !mucInfo.autoEnterRoom;
UpdateView(mucInfo);
MUCDBManager.INSTANCE.setMUCChatInfo(mucInfo, false, true);
}).ConfAwaitFalse();
}
public void UpdateViewMuc(ChatTable chat, MUCChatInfoTable muc)
{
if (!(muc is null) && !(chat is null))
{
NameText = string.IsNullOrWhiteSpace(muc.name) ? chat.chatJabberId : muc.name;
RemoveFromRosterText = chat.inRoster ? "Remove bookmark" : "Bookmark";
// Account image:
AccountPresence = muc.getMUCPresence();
AccountInitials = "\uE125";
MucState = muc.state;
}
}
protected override DataTemplate SelectTemplateCore(object item, DependencyObject container)
{
if (item is ChatMessageDataTemplate)
{
ChatMessageDataTemplate template = item as ChatMessageDataTemplate;
if (template.message != null && template.chat != null)
{
switch (template.message.type)
{
case MessageMessage.TYPE_ERROR:
return(errorMessageTemplate);
case MessageMessage.TYPE_GROUPCHAT:
if (!requestedMUCInfo)
{
mucInfo = getMUCInfo(container);
requestedMUCInfo = true;
}
if (mucInfo != null && Equals(mucInfo.nickname, template.message.fromUser))
{
return(sendMessageTemplate);
}
else
{
return(receivedMessageTemplate);
}
case DirectMUCInvitationMessage.TYPE_MUC_DIRECT_INVITATION:
return(mucDirectInvitationTemplate);
case MUCHandler.TYPE_CHAT_INFO:
return(infoMessageTemplate);
default:
if (template.chat.userAccountId.Equals(template.message.fromUser))
{
return(sendMessageTemplate);
}
else
{
return(receivedMessageTemplate);
}
}
}
}
return(base.SelectTemplateCore(item, container));
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
if (e.Parameter is NavigatedToMUCInfoEventArgs)
{
NavigatedToMUCInfoEventArgs args = e.Parameter as NavigatedToMUCInfoEventArgs;
Client = args.CLIENT;
Chat = args.CHAT;
MUCInfo = args.MUC_INFO;
ChatDBManager.INSTANCE.ChatChanged -= INSTANCE_ChatChanged;
ChatDBManager.INSTANCE.ChatChanged += INSTANCE_ChatChanged;
MUCDBManager.INSTANCE.MUCInfoChanged -= INSTANCE_MUCInfoChanged;
MUCDBManager.INSTANCE.MUCInfoChanged += INSTANCE_MUCInfoChanged;
}
}
public void UpdateViewChat(ChatTable chat, MUCChatInfoTable muc)
{
if (!(chat is null))
{
// Do not reload chat messages, if for example only the presence changes:
if (!isDummy && (this.chat is null || !string.Equals(chat.id, this.chat.id)))
{
LoadChatMessages(chat, muc);
}
this.chat = chat;
if (isDummy)
{
AccountText = chat.userAccountId;
}
if (chat.chatType == ChatType.MUC)
{
OmemoVisability = Visibility.Collapsed;
if (muc.state != MUCState.ENTERD && muc.state != MUCState.ENTERING)
{
EnterMucVisability = Visibility.Visible;
LeaveMucVisability = Visibility.Collapsed;
}
else
{
EnterMucVisability = Visibility.Collapsed;
LeaveMucVisability = Visibility.Visible;
}
}
else
{
NameText = chat.chatJabberId ?? "";
StatusText = chat.chatState ?? chat.status ?? "";
EnterMucVisability = Visibility.Collapsed;
LeaveMucVisability = Visibility.Collapsed;
OmemoEnabled = chat.omemoEnabled;
OmemoVisability = Visibility.Visible;
}
// Account image:
AccountPresence = chat.presence;
AccountInitials = "\uE77B";
}
public void setMUCChatInfo(MUCChatInfoTable info, bool delete, bool triggerMUCChanged)
{
if (info != null)
{
if (delete)
{
dB.Delete(info);
}
else
{
update(info);
}
if (triggerMUCChanged)
{
MUCInfoChanged?.Invoke(this, new MUCInfoChangedEventArgs(info, delete));
}
}
}
private async Task SendChatMessageAsync(ChatTable chat, string message)
{
AccountTable account = AccountDBManager.INSTANCE.getAccount(chat.userAccountId);
if (account is null)
{
Logger.Warn("Unable to send message - no such account: " + chat.userAccountId);
return;
}
string fromBareJid = account.userId + '@' + account.domain;
string fromFullJid = fromBareJid + '/' + account.resource;
string to = chat.chatJabberId;
string chatType = chat.chatType == ChatType.CHAT ? MessageMessage.TYPE_CHAT : MessageMessage.TYPE_GROUPCHAT;
bool reciptRequested = true;
MessageMessage toSendMsg;
if (chat.omemoEnabled)
{
if (chat.chatType == ChatType.CHAT)
{
toSendMsg = new OmemoMessageMessage(fromFullJid, to, message, chatType, reciptRequested);
}
else
{
// ToDo: Add MUC OMEMO support
throw new NotImplementedException("Sending encrypted messages for MUC is not supported right now!");
}
}
else if (chat.chatType == ChatType.CHAT)
{
toSendMsg = new MessageMessage(fromFullJid, to, message, chatType, reciptRequested);
}
else
{
MUCChatInfoTable mucInfo = MUCDBManager.INSTANCE.getMUCInfo(chat.id);
toSendMsg = new MessageMessage(fromFullJid, to, message, chatType, mucInfo.nickname, reciptRequested);
}
// Create a copy for the DB:
ChatMessageTable toSendMsgDB = new ChatMessageTable(toSendMsg, chat)
{
state = toSendMsg is OmemoMessageMessage ? MessageState.TO_ENCRYPT : MessageState.SENDING
};
// Set the chat message id for later identification:
toSendMsg.chatMessageId = toSendMsgDB.id;
// Update chat last active:
chat.lastActive = DateTime.Now;
// Update DB:
ChatDBManager.INSTANCE.setChatMessage(toSendMsgDB, true, false);
ChatDBManager.INSTANCE.setChat(chat, false, true);
Logger.Info("Added to send message in background");
if (isRunning)
{
XMPPClient client = ConnectionHandler.INSTANCE.getClient(fromBareJid);
if (client is null)
{
Logger.Error("Unable to send message in background - no such client: " + fromBareJid);
}
// Send the message:
else if (toSendMsg is OmemoMessageMessage toSendOmemoMsg)
{
await client.sendOmemoMessageAsync(toSendOmemoMsg, chat.chatJabberId, client.getXMPPAccount().getBareJid());
}
else
{
await client.SendAsync(toSendMsg);
}
}
else
{
ToastHelper.showWillBeSendLaterToast(chat);
}
}
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\
#region --Constructors--
/// <summary>
/// Basic Constructor
/// </summary>
/// <history>
/// 05/02/2018 Created [Fabian Sauter]
/// </history>
public NavigatedToMUCInfoEventArgs(ChatTable chat, XMPPClient client, MUCChatInfoTable mucInfo)
{
this.CHAT = chat;
this.CLIENT = client;
this.MUC_INFO = mucInfo;
}
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\
#region --Constructors--
public NavigatedToMucInfoPageEventArgs(XMPPClient client, ChatTable chat, MUCChatInfoTable mucInfo)
{
CHAT = chat;
CLIENT = client;
MUC_INFO = mucInfo;
}
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 async Task sendMUCLeaveMessageAsync(XMPPClient client, ChatTable muc, MUCChatInfoTable info)
{
string from = client.getXMPPAccount().getFullJid();
string to = muc.chatJabberId + '/' + info.nickname;
LeaveRoomMessage msg = new LeaveRoomMessage(from, to);
await client.sendAsync(msg);
}
