private async void OnRelayMessagesUpdated()
{
var newMessages = await SignaledInstantMessages.GetAllFromAsync(_userId);
var filteredNewMessages = newMessages
.OrderBy(s => s.SentDateTimeUtc).ToList();
foreach (var message in filteredNewMessages)
{
await SignaledInstantMessages.DeleteAsync(message.Id);
((ObservableCollection <InstantMessageViewModel>)InstantMessages).Add(new InstantMessageViewModel
{
Body = message.Payload,
DeliveredAt = message.SentDateTimeUtc.LocalDateTime,
IsSender = false,
SenderName = Name,
SenderProfileSource = ProfileSource,
IsHighlighted = !_isSelected
});
ETWEventLogger.Instance.LogEvent("Incomming Message",
"SenderName is " + message.FromName + " ReceiverName is " + RegistrationSettings.Name
+ "\n SendDateTimeUtc " + message.SentDateTimeUtc.ToString(),
DateTimeOffset.Now.ToUnixTimeMilliseconds().ToString());
}
if (!_isSelected && filteredNewMessages.Count > 0)
{
IsHighlighted = true;
}
}
public IAsyncAction DisconnectSignalingServerAsync()
{
return(Task.Run(async() =>
{
SocketOperation.Disconnect();
SignaledPeerData.Reset();
SignalingStatus.Reset();
await SignaledInstantMessages.ResetAsync();
}).AsAsyncAction());
}
public IAsyncAction ServerRelayAsync(RelayMessage message)
{
return(Task.Run(async() =>
{
await ClientConfirmationAsync(Confirmation.For(message));
if (message.Tag == RelayMessageTags.InstantMessage)
{
await SignaledInstantMessages.AddAsync(message);
}
var shownUserId = await _foregroundChannel.GetShownUserIdAsync();
if (message.Tag == RelayMessageTags.InstantMessage &&
!ReceivedPushNotifications.IsReceived(message.Id) &&
!(shownUserId != null && shownUserId.Equals(message.FromUserId)) &&
(DateTimeOffset.UtcNow.Subtract(message.SentDateTimeUtc).TotalMinutes < 10))
{
ToastNotificationService.ShowInstantMessageNotification(message.FromName,
message.FromUserId, AvatarLink.EmbeddedLinkFor(message.FromAvatar), message.Payload);
}
_foregroundChannel?.OnSignaledRelayMessagesUpdatedAsync();
// Handle call tags
if (message.Tag == RelayMessageTags.Call)
{
await _callChannel.OnIncomingCallAsync(message);
}
else if (message.Tag == RelayMessageTags.CallAnswer)
{
await _callChannel.OnOutgoingCallAcceptedAsync(message);
}
else if (message.Tag == RelayMessageTags.CallReject)
{
await _callChannel.OnOutgoingCallRejectedAsync(message);
}
else if (message.Tag == RelayMessageTags.SdpOffer)
{
await _callChannel.OnSdpOfferAsync(message);
}
else if (message.Tag == RelayMessageTags.SdpAnswer)
{
await _callChannel.OnSdpAnswerAsync(message);
}
else if (message.Tag == RelayMessageTags.IceCandidate)
{
await _callChannel.OnIceCandidateAsync(message);
}
else if (message.Tag == RelayMessageTags.CallHangup)
{
await _callChannel.OnRemoteHangupAsync(message);
}
}).AsAsyncAction());
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
using (new BackgroundTaskDeferralWrapper(taskInstance.GetDeferral()))
{
try
{
var rawNotification = (RawNotification)taskInstance.TriggerDetails;
var rawContent = rawNotification.Content;
var serializedParameter =
rawContent.Substring(rawContent.IndexOf(" ", StringComparison.CurrentCultureIgnoreCase) + 1);
var type = typeof(RelayMessage);
var message = (RelayMessage)JsonConvert.DeserializeObject(serializedParameter, type);
if (message == null)
{
return;
}
var isTimeout = (DateTimeOffset.UtcNow - message.SentDateTimeUtc).TotalSeconds > 60;
if (message.Tag == RelayMessageTags.Call)
{
if (isTimeout)
{
return;
}
ToastNotificationService.ShowInstantMessageNotification(message.FromName, message.FromUserId,
AvatarLink.EmbeddedLinkFor(message.FromAvatar),
$"Missed call at {message.SentDateTimeUtc.ToLocalTime()}.");
}
else if (message.Tag == RelayMessageTags.InstantMessage)
{
if (isTimeout || await SignaledInstantMessages.IsReceivedAsync(message.Id))
{
return;
}
ToastNotificationService.ShowInstantMessageNotification(message.FromName, message.FromUserId,
AvatarLink.EmbeddedLinkFor(message.FromAvatar), message.Payload);
ReceivedPushNotifications.Add(message.Id);
await SignaledInstantMessages.AddAsync(message);
}
}
catch (Exception)
{
}
}
}
public IAsyncOperation <ConnectionStatus> ConnectToSignalingServerAsync(ConnectionOwner connectionOwner)
{
return(Task.Run(async() =>
{
try
{
SignaledPeerData.Reset();
SignalingStatus.Reset();
await SignaledInstantMessages.ResetAsync();
var socket = new StreamSocket();
socket.EnableTransferOwnership(Guid.Parse(connectionOwner.OwnerId),
SocketActivityConnectedStandbyAction.Wake);
var connectCancellationTokenSource = new CancellationTokenSource(2000);
var connectAsync = socket.ConnectAsync(new HostName(SignalingSettings.SignalingServerHost),
SignalingSettings.SignalingServerPort, SocketProtectionLevel.PlainSocket);
var connectTask = connectAsync.AsTask(connectCancellationTokenSource.Token);
await connectTask;
socket.TransferOwnership(SignalingSocketOperation.SignalingSocketId);
return new ConnectionStatus
{
IsConnected = true
};
}
catch (Exception exception)
{
Debug.WriteLine("Failed to connect to signalling server: ex: " + exception.Message);
return new ConnectionStatus
{
IsConnected = false
};
}
}).AsAsyncOperation());
}
