public void OnWebSocketMessage(string _message)
        {
            // Check HubConnection is Registered Connected
            if (App.HubConnection.State != HubConnectionState.Connected)
            {
                logger.Error(TAG, $"The SignalR HubConnection is in a Non-Connected State");
                return;
            }

            var _signalingMessage = SignalingMessage.MessageFromJSONString(_message);

            switch (_signalingMessage.Type)
            {
            case SignalingMessageType.Candidate:
                var candidate = (ICECandidateMessage)_signalingMessage;
                signalingEvents.OnRemoteIceCandidate(candidate.Candidate);
                break;

            case SignalingMessageType.CandidateRemoval:
                var candidates = (ICECandidateRemovalMessage)_signalingMessage;
                signalingEvents.OnRemoteIceCandidatesRemoved(candidates.Candidates);
                break;

            case SignalingMessageType.Offer:
                if (!isInitiator)
                {
                    var sdp = (SessionDescriptionMessage)_signalingMessage;
                    signalingEvents.OnRemoteDescription(sdp.Description);
                }
                else
                {
                    ReportError($"Received offer for call receiver : {_message}");
                }
                break;

            case SignalingMessageType.Answer:
                if (isInitiator)
                {
                    var sdp = (SessionDescriptionMessage)_signalingMessage;
                    signalingEvents.OnRemoteDescription(sdp.Description);
                }
                else
                {
                    ReportError($"Received answer for call initiator: {_message}");
                }
                break;

            case SignalingMessageType.Bye:
                signalingEvents.OnChannelClose();
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Beispiel #2
0
        public void OnWebSocketMessage(string message)
        {
            if (_wsClient.State != WebSocketConnectionState.Registered)
            {
                _logger.Error(TAG, "Got WebSocket message in non registered state.");
                return;
            }

            var msg = SignalingMessage.MessageFromJSONString(message);

            switch (msg.Type)
            {
            case SignalingMessageType.Candidate:
                var candidate = (ICECandidateMessage)msg;
                _signalingEvents.OnRemoteIceCandidate(candidate.Candidate);
                break;

            case SignalingMessageType.CandidateRemoval:
                var candidates = (ICECandidateRemovalMessage)msg;
                _signalingEvents.OnRemoteIceCandidatesRemoved(candidates.Candidates);
                break;

            case SignalingMessageType.Offer:
                if (!_initiator)
                {
                    var sdp = (SessionDescriptionMessage)msg;
                    _signalingEvents.OnRemoteDescription(sdp.Description);
                }
                else
                {
                    ReportError($"Received offer for call receiver : {message}");
                }
                break;

            case SignalingMessageType.Answer:
                if (_initiator)
                {
                    var sdp = (SessionDescriptionMessage)msg;
                    _signalingEvents.OnRemoteDescription(sdp.Description);
                }
                else
                {
                    ReportError($"Received answer for call initiator: {message}");
                }
                break;

            case SignalingMessageType.Bye:
                _signalingEvents.OnChannelClose();
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
        public void OnWebSocketMessage(string message)
        {
            if (_wsClient.State != WebSocketConnectionState.Registered)
            {
                _logger.Error(TAG, "Got WebSocket message in non registered state.");
                return;
            }

            var msg = SignalingMessage.FromJson(message);

            switch (msg.MessageType)
            {
            case SignalingMessageType.Unknown:
                _logger.Error(TAG, $"Got unknown message: {message}");
                break;

            case SignalingMessageType.Register:
            case SignalingMessageType.Offer:
            case SignalingMessageType.SendCandidate:
                _logger.Error(TAG, $"Got wrong message type: {msg.MessageType}");
                break;

            case SignalingMessageType.Registered:
                var registerMessage = (RegisteredMessage)msg;
                SignalingParametersReady(registerMessage);
                break;

            case SignalingMessageType.ReceivedAnswer:
                var answerMessage = (SessionDescriptionMessage)msg;
                _signalingEvents.OnRemoteDescription(answerMessage.Description);
                break;

            case SignalingMessageType.ReceiveCandidate:
                var candidateMessage = (IceCandidateMessage)msg;
                var iceCandidate     = candidateMessage.IceCandidate;
                _signalingEvents.OnRemoteIceCandidate(new IceCandidate(iceCandidate.Sdp, iceCandidate.SdpMid,
                                                                       iceCandidate.SdpMLineIndex));
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }