public override async Task OnIceCandidate(RelayMessage message)
{
var candidates = (DtoIceCandidates)JsonConvert.Deserialize(message.Payload, typeof(DtoIceCandidates));
foreach (var candidate in candidates.Candidates)
{
await Context.PeerConnection.AddIceCandidate(candidate.FromDto());
}
}
public void OnIceCandidate(RelayMessage message)
{
Task.Run(() =>
{
Debug.WriteLine("VoipChannel.OnIceCandidate");
Context.WithState(st => st.OnIceCandidate(message)).Wait();
});
}
public void Relay(RelayMessage message)
{
if (_signalingClient == null)
{
_signalingClient = _container.Resolve<SignalingClient>();
}
_signalingClient.Relay(message);
}
public static void Add(RelayMessage message)
{
var messageContainer = RelayMessageContainer.CreateContainer(message.Id,
ApplicationDataCreateDisposition.Always);
messageContainer.Values.AddOrUpdate(nameof(RelayMessage.Id), message.Id);
messageContainer.Values.AddOrUpdate(nameof(RelayMessage.SentDateTimeUtc), message.SentDateTimeUtc);
messageContainer.Values.AddOrUpdate(nameof(RelayMessage.FromUserId), message.FromUserId);
messageContainer.Values.AddOrUpdate(nameof(RelayMessage.ToUserId), message.ToUserId);
messageContainer.Values.AddOrUpdate(nameof(RelayMessage.Payload), message.Payload);
messageContainer.Values.AddOrUpdate(nameof(RelayMessage.Tag), message.Tag);
}
public void StartIncomingCall(RelayMessage message)
{
var foregroundIsVisible = false;
var state = Hub.Instance.ForegroundClient.GetForegroundState();
if (state != null) foregroundIsVisible = state.IsForegroundVisible;
if (!foregroundIsVisible)
{
var voipCallCoordinatorCc = VoipCallCoordinator.GetDefault();
VoipCall = voipCallCoordinatorCc.RequestNewIncomingCall(message.FromUserId, message.FromName, message.FromName,
AvatarLink.CallCoordinatorUriFor(message.FromAvatar),
"ChatterBox Universal",
null,
"",
null,
VoipPhoneCallMedia.Audio,
new TimeSpan(0, 1, 20));
SubscribeToVoipCallEvents();
}
}
public void StartIncomingCall(RelayMessage message)
{
}
public void SetActiveIncomingCall(RelayMessage message, bool videoEnabled)
{
}
public virtual async Task OnIceCandidate(RelayMessage message)
{
}
public override async Task OnOutgoingCallRejected(RelayMessage message)
{
var hangingUpState = new VoipState_HangingUp();
await Context.SwitchState(hangingUpState);
}
public override async Task OnRemoteHangup(RelayMessage message)
{
var hangingUpState = new VoipState_HangingUp();
await Context.SwitchState(hangingUpState);
}
public void ServerRelay(RelayMessage message)
{
}
public virtual async Task OnRemoteHangup(RelayMessage message)
{
}
public virtual async Task OnSdpOffer(RelayMessage message)
{
}
public virtual async Task OnOutgoingCallRejected(RelayMessage message)
{
}
public virtual async Task OnOutgoingCallAccepted(RelayMessage message)
{
}
public virtual async Task OnIncomingCall(RelayMessage message)
{
}
private const int _callDueTimeout = 1000 * 35; //35 seconds, should be bigger than RemoteRinging state timer
public VoipState_LocalRinging(RelayMessage message)
{
_message = message;
_callRequest = (OutgoingCallRequest)JsonConvert.Deserialize(message.Payload, typeof(OutgoingCallRequest));
}
private void OnSendInstantMessageCommandExecute()
{
var message = new RelayMessage
{
SentDateTimeUtc = DateTimeOffset.UtcNow,
ToUserId = UserId,
FromUserId = RegistrationSettings.UserId,
Payload = InstantMessage.Trim(),
Tag = RelayMessageTags.InstantMessage
};
InstantMessage = null;
_clientChannel.Relay(message);
InstantMessages.Add(new InstantMessageViewModel
{
Message = message.Payload,
DateTime = message.SentDateTimeUtc.LocalDateTime,
IsSender = true,
Sender = RegistrationSettings.Name
});
}
public void Relay(RelayMessage message)
{
}
public override async Task OnIncomingCall(RelayMessage message)
{
var localRingingState = new VoipState_LocalRinging(message);
await Context.SwitchState(localRingingState);
}
public void Relay(RelayMessage message)
{
_signalingClient.Relay(message);
}
private void RegisteredClient_OnRelayMessage(RegisteredClient sender, RelayMessage message)
{
RegisteredClient receiver;
if (!Clients.TryGetValue(message.ToUserId, out receiver))
{
return;
}
message.FromUserId = sender.UserId;
message.FromName = sender.Name;
message.FromAvatar = sender.Avatar;
receiver.ServerRelay(message);
}
public override async Task OnOutgoingCallAccepted(RelayMessage message)
{
var establishOutgoingState = new VoipState_EstablishOutgoing(_request);
await Context.SwitchState(establishOutgoingState);
}
public void ServerRelay(RelayMessage message)
{
ClientConfirmation(Confirmation.For(message));
SignaledRelayMessages.Add(message);
var shownUserId = _foregroundChannel.GetShownUserId();
if (message.Tag == RelayMessageTags.InstantMessage &&
!SignaledRelayMessages.IsPushNotificationReceived(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?.OnSignaledRelayMessagesUpdated();
// Handle Voip tags
if (message.Tag == RelayMessageTags.VoipCall)
{
_voipChannel.OnIncomingCall(message);
}
else if (message.Tag == RelayMessageTags.VoipAnswer)
{
_voipChannel.OnOutgoingCallAccepted(message);
}
else if (message.Tag == RelayMessageTags.VoipReject)
{
_voipChannel.OnOutgoingCallRejected(message);
}
else if (message.Tag == RelayMessageTags.SdpOffer)
{
_voipChannel.OnSdpOffer(message);
}
else if (message.Tag == RelayMessageTags.SdpAnswer)
{
_voipChannel.OnSdpAnswer(message);
}
else if (message.Tag == RelayMessageTags.IceCandidate)
{
_voipChannel.OnIceCandidate(message);
}
else if (message.Tag == RelayMessageTags.VoipHangup)
{
_voipChannel.OnRemoteHangup(message);
}
}
private void OnSendInstantMessageCommandExecute()
{
var message = new RelayMessage
{
SentDateTimeUtc = DateTimeOffset.UtcNow,
ToUserId = UserId,
FromUserId = RegistrationSettings.UserId,
Payload = InstantMessage.Trim(),
Tag = RelayMessageTags.InstantMessage
};
InstantMessage = null;
_clientChannel.Relay(message);
((ObservableCollection<InstantMessageViewModel>)InstantMessages).Add(new InstantMessageViewModel
{
Body = message.Payload,
DeliveredAt = message.SentDateTimeUtc.LocalDateTime,
IsSender = true,
SenderName = RegistrationSettings.Name,
SenderProfileSource = OwnProfileSource
});
}
public void OnSdpOffer(RelayMessage message)
{
Task.Run(() =>
{
Debug.WriteLine("VoipChannel.OnSdpOffer");
Context.WithState(st => st.OnSdpOffer(message)).Wait();
});
}
public void SetActiveIncomingCall(RelayMessage message, bool videoEnabled)
{
SetActiveCall(message.FromUserId, message.FromName, videoEnabled);
}
public override async Task OnSdpAnswer(RelayMessage message)
{
await
Context.PeerConnection.SetRemoteDescription(new RTCSessionDescription(RTCSdpType.Answer, message.Payload));
await Context.SwitchState(new VoipState_ActiveCall(_callRequest));
}
public async void Relay(RelayMessage message)
{
await SendToServer(message);
}
public override async Task OnSdpOffer(RelayMessage message)
{
await
Context.PeerConnection.SetRemoteDescription(new RTCSessionDescription(RTCSdpType.Offer, message.Payload));
var sdpAnswer = await Context.PeerConnection.CreateAnswer();
await Context.PeerConnection.SetLocalDescription(sdpAnswer);
Context.SendToPeer(RelayMessageTags.SdpAnswer, sdpAnswer.Sdp);
await Context.SwitchState(new VoipState_ActiveCall(_callRequest));
}
