private async void Store_StoreChanged(ChatMessageStore sender, ChatMessageStoreChangedEventArgs args)
{
if (args.Id != _messageid)
{
return;
}
switch (args.Kind)
{
case ChatStoreChangedEventKind.MessageDeleted:
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
MessageBody = "Deleted message";
});
DropEvents();
break;
}
case ChatStoreChangedEventKind.MessageModified:
{
(var body, var ts) = await GetMessageInfo();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
(MessageBody, TimeStamp) = (body, ts);
});
break;
}
}
}
// Initialize Stuff
public async void Initialize()
{
BackgroundTaskUtils.RegisterToastNotificationBackgroundTasks();
ContactUtils.AssignAppToPhoneContacts();
_store = await ChatMessageManager.RequestStoreAsync();
ChatConversations = await GetChats();
if (ChatConversations.Count != 0)
{
SelectedItem = ChatConversations[0];
}
if (!(await PerformMandatoryChecks()))
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() =>
{
await new CellularUnavailableContentDialog().ShowAsync();
});
}
_store.ChangeTracker.Enable();
_store.StoreChanged += Store_StoreChanged;
}
// Initialize Stuff
public async void Initialize(string ConvoId)
{
if (string.IsNullOrEmpty(ConvoId))
{
return;
}
_store = await ChatMessageManager.RequestStoreAsync();
_conversationid = ConvoId;
var convo = await _store.GetConversationAsync(_conversationid);
if (convo == null)
{
DropEvents();
return;
}
(var tmpContact, var tmpDisplayName) = await GetContactInformation();
(DisplayDescription, TimeStamp) = await GetLastMessageInfo();
(Contact, DisplayName) = (tmpContact, tmpDisplayName);
_store.ChangeTracker.Enable();
Subscribe(true);
}
// Initialize Stuff
public async void Initialize(string MessageId)
{
if (string.IsNullOrEmpty(MessageId))
{
return;
}
_store = await ChatMessageManager.RequestStoreAsync();
_messageid = MessageId;
var _tmpContact = await GetContactInformation();
(var _align, var _visi) = await GetMessageVisuals();
(MessageBody, TimeStamp) = await GetMessageInfo();
(Alignment, IncomingVisibility) = (_align, _visi);
Contact = _tmpContact;
var message = await _store.GetMessageAsync(_messageid);
foreach (var attachment in message.Attachments)
{
try
{
if (attachment.MimeType == "application/smil")
{
}
if (attachment.MimeType == "text/vcard")
{
}
if (attachment.MimeType.StartsWith("image/", StringComparison.InvariantCulture))
{
var imageextension = attachment.MimeType.Split('/').Last();
var img = new BitmapImage();
await img.SetSourceAsync(await attachment.DataStreamReference.OpenReadAsync());
Image = img;
}
if (attachment.MimeType.StartsWith("audio/", StringComparison.InvariantCulture))
{
var audioextension = attachment.MimeType.Split('/').Last();
}
}
catch
{
}
}
_store.ChangeTracker.Enable();
Subscribe(true);
}
private async void SendButton_Click(object sender, RoutedEventArgs e)
{
ChatMessageStore store = await ChatMessageManager.RequestStoreAsync();
var mess = new ChatMessage
{
Body = MessageTB.Text,
TransportId = "0"
};
foreach (var rec in messagethread.ChatConversation.Participants)
{
mess.Recipients.Add(rec);
}
if (MessageTB.Text.Length > 0)
{
try
{
foreach (var recipient in messagethread.ChatConversation.Participants)
{
sendtext(MessageTB.Text, recipient);
}
try
{
await store.SendMessageAsync(mess);
}
catch (Exception ex)
{
var nsg = new MessageDialog(ex.Message);
await nsg.ShowAsync();
//try
//{
// await Windows.ApplicationModel.Chat.ChatMessageManager.ShowComposeSmsMessageAsync(mess);
//}
//catch (Exception ex2)
//{
// var nsg2 = new MessageDialog(ex2.Message);
// await nsg2.ShowAsync();
//}
}
var mesage = new Message
{
Body = MessageTB.Text,
Alignment = HorizontalAlignment.Right,
Color = (Windows.UI.Color)Application.Current.Resources["SystemAccentColorLight1"],
DateTime = DateTime.Now.ToString("MM/dd, HH:mm"),
Margin = new Thickness(60, 10, 10, 10)
};
Conversation.Add(mesage);
}
catch
{
}
}
}
public static ChatMessageStore RequestStore(XmppAddress address)
{
lock (syncObject)
{
if (store == null)
{
store = new ChatMessageStore();
}
}
return(store);
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
// A message has been received from a sender not on the block list.
// We must decide whether to block it or to allow it.
var deferral = taskInstance.GetDeferral();
Dictionary <string, ChatMessageTransportKind> transportIdToTransportKind = new Dictionary <string, ChatMessageTransportKind>();
// Prepare the mapping for TransportKind check
var transports = await ChatMessageManager.GetTransportsAsync();
foreach (ChatMessageTransport transport in transports)
{
transportIdToTransportKind[transport.TransportId] = transport.TransportKind;
}
ChatMessageStore msgStore = await ChatMessageManager.RequestStoreAsync();
// Untriaged is a transient status for less than 1 second.
// If a message is not blocked in time, the status will be changed by system.
// The message blocked by block list will not fire this trigger.
ChatMessageReader msgReader = msgStore.GetMessageReader(TimeSpan.FromSeconds(1));
var msgList = await msgReader.ReadBatchAsync();
foreach (ChatMessage msg in msgList)
{
if (transportIdToTransportKind[msg.TransportId] == ChatMessageTransportKind.Untriaged)
{
// Check if the message should be blocked.
// This sample blocks messages whose text is "block me".
if (msg.Body == "block me")
{
try
{
await ChatMessageBlocking.MarkMessageAsBlockedAsync(msg.Id, true);
}
catch (System.UnauthorizedAccessException)
{
// Untriaged message will be recalled by system in 1 second.
Toast.Send("Block failed due to timeout");
}
}
}
}
deferral.Complete();
}
// Initialize Stuff
public async void Initialize(string ConvoId)
{
if (string.IsNullOrEmpty(ConvoId))
{
return;
}
if (ChatMessages != null && ChatMessages.Count != 0)
{
foreach (var msg in ChatMessages)
{
msg.ViewModel.DropEvents();
}
}
if (ConvoId != _conversationid)
{
DropEvents();
}
_store = await ChatMessageManager.RequestStoreAsync();
_conversationid = ConvoId;
var _tmpchatMessages = await GetMessages();
var _tmpCellLines = await GetSmsDevices();
(Contact, DisplayName) = await GetContactInformation();
ChatMessages = _tmpchatMessages;
ChatMessages.CollectionChanged += ChatMessages_CollectionChanged;
CellularLines = _tmpCellLines;
if (CellularLines.Count != 0)
{
SelectedLine = CellularLines[0];
}
_store.ChangeTracker.Enable();
Subscribe(true);
}
private async void GetMessages()
{
try
{
var contactStore = await ContactManager.RequestStoreAsync();
var contacts = await contactStore.FindContactsAsync();
ChatMessageStore store = await ChatMessageManager.RequestStoreAsync();
var derp = store.GetConversationReader();
var batch = await derp.ReadBatchAsync();
foreach (var item in batch)
{
try
{
Messagelist.Add(new MessageThread
{
ChatConversation = item,
Participant = GetParticipants(item.Participants),
ParticipantPhoto = await GetPhoto(contactStore, item),
RecentMessage = await Getrecentmessage(item.MostRecentMessageId, item.GetMessageReader()),
DateTime = await GetrecentmessageTime(item.MostRecentMessageId, item.GetMessageReader()),
});
}
catch (Exception ex)
{
var msgderp = new MessageDialog(ex.Message);
await msgderp.ShowAsync();
}
}
ConvoList.ItemsSource = Messagelist;
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
private async void Store_StoreChanged(ChatMessageStore sender, ChatMessageStoreChangedEventArgs args)
{
if (args.Id != _conversationid)
{
return;
}
switch (args.Kind)
{
case ChatStoreChangedEventKind.ConversationModified:
{
var conversation = await _store.GetConversationAsync(args.Id);
if (conversation == null)
{
DropEvents();
break;
}
(var str, var dt) = await GetLastMessageInfo();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
(DisplayDescription, TimeStamp) = (str, dt);
});
break;
}
case ChatStoreChangedEventKind.ConversationDeleted:
{
DropEvents();
break;
}
}
}
private async void Store_StoreChanged(ChatMessageStore sender, ChatMessageStoreChangedEventArgs args)
{
if (args.Id != _conversationid)
{
return;
}
switch (args.Kind)
{
case ChatStoreChangedEventKind.ConversationModified:
{
var conversation = await _store.GetConversationAsync(args.Id);
if (conversation == null)
{
DropEvents();
break;
}
UpdateMessages();
break;
}
}
}
public async static Task <bool> SendTextMessageAsync(SmsDevice2 device, string[] numbers, string textmessage, string transportId = "0")
{
bool returnresult = true;
ChatMessageStore store = await ChatMessageManager.RequestStoreAsync();
if (string.IsNullOrEmpty(transportId) || await ChatMessageManager.GetTransportAsync(transportId) == null)
{
var transports = await ChatMessageManager.GetTransportsAsync();
if (transports.Count != 0)
{
var transport = transports[0];
transportId = transport.TransportId;
}
else
{
transportId = await ChatMessageManager.RegisterTransportAsync();
}
}
try
{
SmsTextMessage2 message = new SmsTextMessage2();
message.Body = textmessage;
foreach (var number in numbers)
{
var num = number.Trim();
message.To = num;
try
{
SmsSendMessageResult result = await device.SendMessageAndGetResultAsync(message);
var offset = new DateTimeOffset(DateTime.Now);
returnresult &= result.IsSuccessful;
try
{
ChatMessage msg = new ChatMessage();
msg.Body = textmessage;
msg.Recipients.Add(num);
msg.LocalTimestamp = offset;
msg.NetworkTimestamp = offset;
msg.IsIncoming = false;
msg.TransportId = transportId;
msg.MessageOperatorKind = ChatMessageOperatorKind.Sms;
msg.Status = result.IsSuccessful ? ChatMessageStatus.Sent : ChatMessageStatus.SendFailed;
await store.SaveMessageAsync(msg);
}
catch
{
}
}
catch
{
returnresult = false;
}
}
}
catch
{
returnresult = false;
}
return(returnresult);
}
private async void Store_StoreChanged(ChatMessageStore sender, ChatMessageStoreChangedEventArgs args)
{
switch (args.Kind)
{
case ChatStoreChangedEventKind.ConversationModified:
{
var conversation = await _store.GetConversationAsync(args.Id);
if (conversation == null)
{
if (ChatConversations.Any(x => x.ConversationId == args.Id))
{
var existingConversation = ChatConversations.First(x => x.ConversationId == args.Id);
bool wasSelected = SelectedItem == existingConversation;
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
ChatConversations.Remove(existingConversation);
if (wasSelected && ChatConversations.Count != 0)
{
SelectedItem = ChatConversations[0];
}
});
}
break;
}
if (!ChatConversations.Any(x => x.ConversationId == args.Id))
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
ChatConversations.Insert(0, new ChatMenuItemControl(conversation.Id));
if (!ChatConversations.Contains(SelectedItem))
{
SelectedItem = ChatConversations[0];
}
});
}
/*else
* {
* var existingConversation = ChatConversations.First(x => x.ConversationId == args.Id);
* await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
* () =>
* {
* bool wasSelected = SelectedItem == existingConversation;
* var newConvo = new ChatMenuItemControl(conversation.Id);
*
* ChatConversations.Remove(existingConversation);
* ChatConversations.Insert(0, newConvo);
*
* if (wasSelected)
* SelectedItem = newConvo;
* });
* }*/
break;
}
case ChatStoreChangedEventKind.ConversationDeleted:
{
if (ChatConversations.Any(x => x.ConversationId == args.Id))
{
var existingConversation = ChatConversations.First(x => x.ConversationId == args.Id);
bool wasSelected = SelectedItem == existingConversation;
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
ChatConversations.Remove(existingConversation);
if (wasSelected && ChatConversations.Count != 0)
{
SelectedItem = ChatConversations[0];
}
});
}
break;
}
}
}
public ChatMessageStoreEvents(ChatMessageStore This)
{
this.This = This;
}
