public void SendDescription(ref RTCSessionDescription desc)
{
Debug.Log($"Send {desc.type}");
var json = JsonUtility.ToJson(SignalingMessage.FromDesc(ref desc));
socket.SendText(json);
}
public void Send(string id, RTCIceCandidate cand)
{
Debug.Log($"Send Candidate to {id}");
var json = JsonUtility.ToJson(SignalingMessage.fromCand(cand));
server.WebSocketServices["/"].Sessions[id].Context.WebSocket.Send(json);
}
private IEnumerator OnCreateAnswerSuccess(RTCSessionDescription desc)
{
Debug.Log("SetLocalDescription start");
var op = pc.SetLocalDescription(ref desc);
yield return(op);
if (!op.IsError)
{
Debug.Log("SetLocalDescription succeed");
}
else
{
Debug.Log("SetLocalDescription failed");
}
var message = new SignalingMessage {
type = "answer",
data = new SignalingMessageData {
type = "answer",
sdp = desc.sdp
}
};
SendMessage(message);
}
private void SendViaSocket(SignalingMessage msg)
{
var json = JsonConvert.SerializeObject(msg);
var nsMsg = new NSString(json, NSStringEncoding.UTF8);
_socket.Send(nsMsg);
}
public void Send(string id, ref RTCSessionDescription desc)
{
Debug.Log($"Send {desc.type} to {id}");
var json = JsonUtility.ToJson(SignalingMessage.fromDesc(ref desc));
server.WebSocketServices["/"].Sessions[id].Context.WebSocket.Send(json);
}
IEnumerator proccessOffer(WebSocket client)
{
Debug.Log("Create Offer");
var op = pc.CreateOffer(ref offerOptions);
yield return(op);
if (!op.isError)
{
var ret = pc.SetLocalDescription(ref op.desc);
yield return(ret);
if (ret.isError)
{
log.Print($"offer setLocalDescription error:{ret.error}");
}
else
{
var offer = new SignalingMessage("offer", op.desc.sdp);
var msg = JsonUtility.ToJson(offer);
Debug.Log("Send Offer");
client.Send(msg);
}
}
else
{
log.Print("create offer error");
}
}
public void SendIce(RTCIceCandidate cand)
{
Debug.Log($"Send Candidate");
var json = JsonUtility.ToJson(SignalingMessage.FromCand(cand));
socket.SendText(json);
}
private void SendSdp(RTCSessionDescription sdp)
{
var signal = new SignalingMessage()
{
Type = sdp.Type.ToString(),
Sdp = sdp.Sdp,
};
SendViaSocket(signal);
}
private void OnIceCandidate(RTCIceCandidate candidate)
{
var message = new SignalingMessage();
var data = new SignalingMessageData();
data.candidate = candidate.Candidate;
data.sdpMid = candidate.SdpMid;
data.sdpMLineIndex = candidate.SdpMLineIndex;
message.type = "candidate";
message.data = data;
SendMessage(message);
}
private void ConnectButton(object sender, EventArgs e)
{
_webRtcClient.Connect((sdp, err) =>
{
if (string.IsNullOrEmpty(err))
{
var signal = new SignalingMessage()
{
Type = sdp.Type.ToString(),
Sdp = sdp.Description,
};
SendViaSocket(signal);
}
});
}
private void SendCandidate(RTCIceCandidate iceCandidate)
{
var can = new Candidate()
{
Sdp = iceCandidate.Sdp,
SdpMLineIndex = iceCandidate.SdpMLineIndex,
SdpMid = iceCandidate.SdpMid
};
var signal = new SignalingMessage()
{
Candidate = can
};
SendViaSocket(signal);
}
private void GreetNode()
{
var message = new SignalingMessage {
type = "message",
data = new SignalingMessageData {
message = "Hello Node!"
}
};
SendMessage(message);
var message1 = new SignalingMessage {
type = "start"
};
SendMessage(message1);
}
public void OnGenerateCandiate(IceCandidate iceCandidate)
{
System.Diagnostics.Debug.WriteLine($"{nameof(OnGenerateCandiate)}");
var can = new Candidate()
{
Sdp = iceCandidate.Sdp,
SdpMLineIndex = iceCandidate.SdpMLineIndex,
SdpMid = iceCandidate.SdpMid
};
var signal = new SignalingMessage()
{
Candidate = can
};
SendViaSocket(signal);
}
void setupPeer(WebSocket client)
{
pc = new RTCPeerConnection(ref conf);
pc.OnIceCandidate = candidate =>
{
log.Print($"onIceCandidate");
var sm = new SignalingMessage(candidate.candidate, candidate.sdpMid, candidate.sdpMLineIndex);
var msg = JsonUtility.ToJson(sm);
ws.Send(msg);
};
foreach (var track in videoStream.GetTracks())
{
pc.AddTrack(track);
}
foreach (var track in audioStream.GetTracks())
{
pc.AddTrack(track);
}
StartCoroutine(proccessOffer(client));
}
public WebRTCSignalingClient(string serverIp, int port)
{
IntPtr zero = IntPtr.Zero;
ValidationUtil.ValidateIsNullOrEmpty(serverIp, nameof(serverIp));
_signalingMessageCallback = (type, message, _) =>
{
Log.Info(WebRTCLog.Tag, $"type:{type}, message:{message}");
if (type == SignalingMessageType.Connected)
{
_isConnected = true;
}
SignalingMessage?.Invoke(this, new WebRTCSignalingEventArgs(type, message));
};
SignalingClient.Connect(serverIp, port, _signalingMessageCallback, zero, out _handle).
ThrowIfFailed("Failed to connect to server");
}
private void HandleWebsocketMessage(byte[] data)
{
SignalingMessage message = JsonUtility.FromJson <SignalingMessage>(Encoding.UTF8.GetString(data));
Debug.LogFormat("Receivied message with type {0}", message.type);
if (localConnection == null)
{
CreatePeerConnection();
}
if (!string.IsNullOrEmpty(message.sdp))
{
StartCoroutine(SetDescription(message.ToDesc(), Side.Remote));
}
if (!string.IsNullOrEmpty(message.candidate))
{
localConnection.AddIceCandidate(message.ToCand());
}
}
private void ReadMessage(SignalingMessage msg)
{
if (msg.Type?.Equals(SessionDescription.SdpType.Offer.ToString(), StringComparison.OrdinalIgnoreCase) == true)
{
_webRtcClient.ReceiveOffer(
new SessionDescription(
SessionDescription.SdpType.Offer,
msg.Sdp),
(sdp, err) =>
{
if (string.IsNullOrEmpty(err))
{
var signal = new SignalingMessage()
{
Type = sdp.Type.ToString(),
Sdp = sdp.Description,
};
SendViaSocket(signal);
}
});
}
else if (msg.Type?.Equals(SessionDescription.SdpType.Answer.ToString(), StringComparison.OrdinalIgnoreCase) == true)
{
_webRtcClient.ReceiveAnswer(
new SessionDescription(
SessionDescription.SdpType.Answer,
msg.Sdp),
(sdp, err) =>
{
});
}
else if (msg.Candidate != null)
{
_webRtcClient.ReceiveCandidate(new IceCandidate(
msg.Candidate.SdpMid,
msg.Candidate.SdpMLineIndex,
msg.Candidate.Sdp));
}
}
private void ReadMessage(SignalingMessage msg)
{
if (msg.Type?.Equals(RTCSdpType.Offer.ToString(), StringComparison.OrdinalIgnoreCase) == true)
{
_webRtcClient.ReceiveOffer(new RTCSessionDescription(RTCSdpType.Offer, msg.Sdp), (sdp, err) =>
{
if (err == null)
{
SendSdp(sdp);
}
});
}
else if (msg.Type?.Equals(RTCSdpType.Answer.ToString(), StringComparison.OrdinalIgnoreCase) == true)
{
_webRtcClient.ReceiveAnswer(new RTCSessionDescription(RTCSdpType.Answer, msg.Sdp), (sdp, err) =>
{
});
}
else if (msg.Candidate != null)
{
_webRtcClient.ReceiveCandidate(new RTCIceCandidate(msg.Candidate.Sdp, msg.Candidate.SdpMLineIndex, msg.Candidate.SdpMid));
}
}
private void SendMessage(SignalingMessage msg)
{
Debug.Log($"Send a(an) \"{msg.type}\" to Node:\n {JsonUtility.ToJson(msg.data, true)}");
ws.Send(JsonUtility.ToJson(msg));
}
private void SendViaSocket(SignalingMessage msg)
{
var json = JsonConvert.SerializeObject(msg);
_socket.Send(json);
}
