private void OnNewDeliveryReceipt(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);
});
}
private void omemo_tmfo_Click(object sender, RoutedEventArgs e)
{
Chat.omemoEnabled = omemo_tmfo.IsChecked;
showChat();
ChatTable cpy = Chat;
Task.Run(() =>
{
ChatDBManager.INSTANCE.setChatTableValue(nameof(cpy.id), cpy.id, nameof(cpy.omemoEnabled), cpy.omemoEnabled);
});
}
private void UpdateView(ChatTable chat)
{
MODEL.BookmarkText = chat.inRoster ? "Remove bookmark" : "Bookmark";
MODEL.ChatBareJid = chat.chatJabberId;
MODEL.MuteGlyph = chat.muted ? "\uE74F" : "\uE767";
MODEL.MuteTooltip = chat.muted ? "Unmute" : "Mute";
if (string.IsNullOrEmpty(MODEL.MucName))
{
MODEL.MucName = chat.chatJabberId;
MODEL.DifferentMucName = !string.Equals(MODEL.ChatBareJid, MODEL.MucName);
}
}
/// <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);
}
public void UpdateLastAction(ChatTable chat)
{
Task.Run(() =>
{
ChatMessageTable lastMsg = ChatDBManager.INSTANCE.getLastChatMessageForChat(chat.id);
if (lastMsg is null)
{
LastActionIconText = "";
LastActionIconVisability = Visibility.Collapsed;
LastActionState = MessageState.READ;
}
else
{
// Text and icon:
LastActionState = lastMsg.state;
if (lastMsg.isImage)
{
LastActionIconText = "\uE722";
LastActionIconVisability = Visibility.Visible;
LastActionText = lastMsg.message ?? "You received an image";
}
else
{
switch (lastMsg.type)
{
case DirectMUCInvitationMessage.TYPE_MUC_DIRECT_INVITATION:
LastActionIconText = "\uE8F2";
LastActionIconVisability = Visibility.Visible;
LastActionText = "You have been invited to a MUC room";
break;
case MessageMessage.TYPE_ERROR:
LastActionIconText = "\xE7BA";
LastActionIconVisability = Visibility.Visible;
LastActionText = lastMsg.message ?? "You received an error message";
break;
case MUCHandler.TYPE_CHAT_INFO:
LastActionIconText = "\uE946";
LastActionIconVisability = Visibility.Visible;
LastActionText = (lastMsg.message ?? "-");
break;
default:
LastActionIconVisability = Visibility.Collapsed;
LastActionText = lastMsg.message ?? "";
break;
}
}
}
});
}
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);
}
}
}
}
protected override async void OnBackgroundActivated(BackgroundActivatedEventArgs args)
{
BackgroundTaskDeferral deferral = args.TaskInstance.GetDeferral();
switch (args.TaskInstance.Task.Name)
{
case BackgroundTaskHelper.TOAST_BACKGROUND_TASK_NAME:
ToastNotificationActionTriggerDetail details = args.TaskInstance.TriggerDetails as ToastNotificationActionTriggerDetail;
if (details != null)
{
InitLogger();
string arguments = details.Argument;
ValueSet userInput = details.UserInput;
Logger.Debug("App activated in background through toast with: " + arguments);
AbstractToastActivation abstractToastActivation = ToastActivationArgumentParser.parseArguments(arguments);
if (abstractToastActivation is null)
{
Logger.Warn("Unable to evaluate toast activation string - unknown format");
}
else if (abstractToastActivation is MarkChatAsReadToastActivation markChatAsRead)
{
ToastHelper.removeToastGroup(markChatAsRead.CHAT_ID);
ChatDBManager.INSTANCE.markAllMessagesAsRead(markChatAsRead.CHAT_ID);
}
else if (abstractToastActivation is MarkMessageAsReadToastActivation markMessageAsRead)
{
ChatDBManager.INSTANCE.markMessageAsRead(markMessageAsRead.CHAT_MESSAGE_ID);
}
else if (abstractToastActivation is SendReplyToastActivation sendReply)
{
ChatTable chat = ChatDBManager.INSTANCE.getChat(sendReply.CHAT_ID);
if (!(chat is null) && userInput[ToastHelper.TEXT_BOX_ID] is string text)
{
string trimedText = text.Trim(UiUtils.TRIM_CHARS);
await SendChatMessageAsync(chat, trimedText);
}
ChatDBManager.INSTANCE.markMessageAsRead(sendReply.CHAT_MESSAGE_ID);
}
ToastHelper.UpdateBadgeNumber();
}
break;
default:
break;
}
deferral.Complete();
}
private static void popToast(ToastContent content, ChatTable chat, string group)
{
ToastNotification toast = new ToastNotification(content.GetXml())
{
Group = group
};
OnChatMessageToastEventArgs args = new OnChatMessageToastEventArgs(toast, chat);
OnChatMessageToast?.Invoke(args);
popToast(toast, args);
}
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);
}
}
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;
}
}
public async Task ToggleChatMutedAsync(ChatTable chat)
{
if (chat is null)
{
return;
}
await Task.Run(() =>
{
chat.muted = !chat.muted;
MODEL.UpdateView(chat);
ChatDBManager.INSTANCE.setChat(chat, false, true);
}).ConfAwaitFalse();
}
private void C_NewBookmarksResultMessage(XMPPClient client, NewBookmarksResultMessageEventArgs args)
{
foreach (ConferenceItem c in args.BOOKMARKS_MESSAGE.STORAGE.CONFERENCES)
{
bool newMUC = false;
string to = client.getXMPPAccount().getBareJid();
string from = c.jid;
string id = ChatTable.generateId(from, to);
// Create / update chat:
ChatTable chat = ChatDBManager.INSTANCE.getChat(id);
if (chat is null)
{
chat = new ChatTable(from, to);
newMUC = true;
}
chat.chatType = ChatType.MUC;
chat.inRoster = true;
chat.presence = Presence.Unavailable;
chat.isChatActive = true;
ChatDBManager.INSTANCE.setChat(chat, false, true);
// Create / update MUC info:
MUCChatInfoTable info = MUCDBManager.INSTANCE.getMUCInfo(chat.id);
if (info is 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));
}
}
}
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 void setChat(ChatTable chat, bool delete, bool triggerChatChanged)
{
if (delete)
{
dB.Delete(chat);
}
else
{
dB.InsertOrReplace(chat);
}
if (triggerChatChanged)
{
onChatChanged(chat, delete);
}
}
/// <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;
}
});
}
protected override void OnBackgroundActivated(BackgroundActivatedEventArgs args)
{
var deferral = args.TaskInstance.GetDeferral();
switch (args.TaskInstance.Task.Name)
{
case BackgroundTaskHelper.TOAST_BACKGROUND_TASK_NAME:
ToastNotificationActionTriggerDetail details = args.TaskInstance.TriggerDetails as ToastNotificationActionTriggerDetail;
if (details != null)
{
initLogLevel();
string arguments = details.Argument;
var userInput = details.UserInput;
Logger.Debug("App activated in background through toast with: " + arguments);
AbstractToastActivation abstractToastActivation = ToastActivationArgumentParser.parseArguments(arguments);
if (abstractToastActivation is MarkChatAsReadToastActivation markChatAsRead)
{
ToastHelper.removeToastGroup(markChatAsRead.CHAT_ID);
ChatDBManager.INSTANCE.markAllMessagesAsRead(markChatAsRead.CHAT_ID);
}
else if (abstractToastActivation is MarkMessageAsReadToastActivation markMessageAsRead)
{
ChatDBManager.INSTANCE.markMessageAsRead(markMessageAsRead.CHAT_MESSAGE_ID);
}
else if (abstractToastActivation is SendReplyToastActivation sendReply)
{
ChatTable chat = ChatDBManager.INSTANCE.getChat(sendReply.CHAT_ID);
if (chat != null && userInput[ToastHelper.TEXT_BOX_ID] != null)
{
if (isRunning)
{
}
else
{
}
}
}
}
break;
}
deferral.Complete();
}
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);
}
}
public void setChat(ChatTable chat, bool delete, bool triggerChatChanged)
{
if (delete)
{
dB.Delete(chat);
OmemoSignalKeyDBManager.INSTANCE.deleteFingerprints(chat.id);
}
else
{
dB.InsertOrReplace(chat);
}
if (triggerChatChanged)
{
onChatChanged(chat, delete);
}
}
/// <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);
}
public void loadDummyContent()
{
Chat = new ChatTable()
{
chatJabberId = "*****@*****.**",
userAccountId = "*****@*****.**",
chatType = ChatType.CHAT,
presence = Presence.Away
};
addDummyMessage("Hi", Chat.userAccountId, MessageState.READ);
addDummyMessage("Hey, what's up?", Chat.chatJabberId, MessageState.SEND);
addDummyMessage("That's a great app.", Chat.userAccountId, MessageState.READ);
message_tbx.Text = "Yes, its awesome :D !";
invertedListView_lstv.Visibility = Visibility.Visible;
loading_ldng.IsLoading = false;
}
void ReleaseDesignerOutlets()
{
if (ChatMessageAuthor != null)
{
ChatMessageAuthor.Dispose();
ChatMessageAuthor = null;
}
if (ChatMessageText != null)
{
ChatMessageText.Dispose();
ChatMessageText = null;
}
if (ChatTable != null)
{
ChatTable.Dispose();
ChatTable = null;
}
if (MessageTextField != null)
{
MessageTextField.Dispose();
MessageTextField = null;
}
if (PeerId != null)
{
PeerId.Dispose();
PeerId = null;
}
if (PeerName != null)
{
PeerName.Dispose();
PeerName = null;
}
if (PeersTable != null)
{
PeersTable.Dispose();
PeersTable = null;
}
}
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";
}
private void showChatMessages(ChatTable newChat, ChatTable oldChat)
{
if (newChat != null)
{
// Only show chat messages if the chat changed:
if (oldChat != null && Equals(newChat.id, oldChat.id))
{
return;
}
// Show loading:
loading_ldng.IsLoading = true;
invertedListView_lstv.Visibility = Visibility.Collapsed;
// Create a copy to prevent multi threading issues:
ChatTable chatCpy = newChat;
Task.Run(async() =>
{
// Mark all unread messages as read for this chat:
ChatDBManager.INSTANCE.markAllMessagesAsRead(chatCpy.id);
// Remove notification group:
ToastHelper.removeToastGroup(chatCpy.id);
// Show all chat messages:
List <ChatMessageDataTemplate> msgs = new List <ChatMessageDataTemplate>();
foreach (ChatMessageTable msg in ChatDBManager.INSTANCE.getAllChatMessagesForChat(chatCpy.id))
{
msgs.Add(new ChatMessageDataTemplate()
{
message = msg,
chat = chatCpy
});
}
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
chatMessages.Clear();
chatMessages.AddRange(msgs);
invertedListView_lstv.Visibility = Visibility.Visible;
loading_ldng.IsLoading = false;
});
});
}
}
private async Task <bool> UpdateBookmarksAsync(ChatTable chat, XMPPClient client)
{
List <ConferenceItem> conferences = MUCDBManager.INSTANCE.getXEP0048ConferenceItemsForAccount(client.getXMPPAccount().getBareJid());
MessageResponseHelperResult <IQMessage> result = await client.PUB_SUB_COMMAND_HELPER.setBookmars_xep_0048Async(conferences);
if (string.Equals(result.RESULT.TYPE, IQMessage.RESULT))
{
return(true);
}
if (result.RESULT is IQErrorMessage errorMessage)
{
Logger.Warn("Failed to update XEP-0048 Bookmarks: " + errorMessage.ERROR_OBJ.ToString());
}
else
{
Logger.Warn("Failed to update XEP-0048 Bookmarks: " + result.RESULT.TYPE);
}
return(false);
}
private void AddDummyMessage(ChatTable chat, string msg, string fromUser, MessageState state, bool isEncrypted, bool isImage)
{
MODEL.CHAT_MESSAGES.Add(new DataTemplates.ChatMessageDataTemplate
{
Chat = chat,
Message = new ChatMessageTable
{
message = msg,
chatId = chat.id,
fromUser = fromUser,
date = DateTime.Now,
state = state,
type = MessageMessage.TYPE_CHAT,
isImage = isImage,
isDummyMessage = true,
isEncrypted = isEncrypted
}
});
}
private void AddDummyMessage(ChatTable chat, string msg, string fromUser, MessageState state, bool isEncrypted, bool isImage)
{
/*MODEL.CHAT_MESSAGES.Add(new DataTemplates.ChatMessageDataTemplate
* {
* Chat = chat,
* Message = new ChatMessageTable
* {
* message = msg,
* chatId = chat.id,
* fromUser = fromUser,
* date = DateTime.Now,
* state = state,
* type = MessageMessage.TYPE_CHAT,
* isImage = isImage,
* isDummyMessage = true,
* isEncrypted = isEncrypted
* }
* });*/
}
private async Task AddIoTDevice(string deviceBareJid, XMPPClient client)
{
// Run it in a new Task since we want to access the DB and this is a blocking action.
await Task.Run(async() =>
{
// Add to DB:
ChatTable chat = new ChatTable(deviceBareJid, client.getXMPPAccount().getBareJid())
{
chatType = ChatType.IOT_DEVICE,
isChatActive = true
};
ChatDBManager.INSTANCE.setChat(chat, false, true);
// Add to the roster:
await client.GENERAL_COMMAND_HELPER.addToRosterAsync(deviceBareJid);
// Add as a PEP node:
// TODO
});
}
private async Task SetChatInRosterAsync(XMPPClient client, ChatTable chat, bool inRoster)
{
if (chat.inRoster != inRoster)
{
await Task.Run(() =>
{
chat.inRoster = inRoster;
MODEL.UpdateView(chat);
ChatDBManager.INSTANCE.setChat(chat, false, true);
}).ConfAwaitFalse();
}
if (inRoster)
{
await client.GENERAL_COMMAND_HELPER.addToRosterAsync(chat.chatJabberId).ConfAwaitFalse();
}
else
{
await client.GENERAL_COMMAND_HELPER.removeFromRosterAsync(chat.chatJabberId).ConfAwaitFalse();
}
}
public static void showChatTextImageToast(ChatMessageTable msg, ChatTable chat)
{
var toastContent = new ToastContent()
{
Visual = new ToastVisual()
{
BindingGeneric = new ToastBindingGeneric()
{
Children =
{
new AdaptiveText()
{
Text = chat.chatJabberId,
HintMaxLines = 1
},
new AdaptiveText()
{
Text = "You received an image!"
}
},
HeroImage = new ToastGenericHeroImage()
{
Source = msg.message
},
AppLogoOverride = new ToastGenericAppLogo()
{
Source = chat.chatType == ChatType.CHAT ? DEFAULT_USER_IMAGE_PATH : DEFAULT_MUC_IMAGE_PATH,
HintCrop = ToastGenericAppLogoCrop.Default
}
}
},
Actions = getActions(msg, chat),
DisplayTimestamp = msg.date,
Launch = new ChatToastActivation(chat.id, false).generate()
};
popToast(toastContent, chat);
}
