public void Disconnect()
{
// pause (i.e. stop sending the server messages)
// because otherwise the socket might throw an exception (invalid write)
Pause();
netClient.Disconnect();
}
/// <summary>
/// Closes any outstanding connections to the media server's control port, and issues the final callback.
/// </summary>
/// <param name="ex"></param>
protected void FinalizeConnection(Exception ex)
{
if (_disposed)
{
return;
}
try
{
if (_connectionTimer != null)
{
_connectionTimer.Change(Timeout.Infinite, Timeout.Infinite);
_connectionTimer = null;
}
if (_controlClient != null && _controlClient.IsConnected)
{
_controlClient.Disconnect();
}
if (_connectionCallback != null)
{
_connectionCallback(ex);
}
}
finally
{
_connectionCallback = null;
}
}
public async void ConnectToServer()
{
INetClient client = await this.ConnectClient();
Assert.Equal(true, client.IsConnected);
client.Disconnect();
}
public void Disconnect()
{
if (m_TCPClient != null)
{
m_TCPClient.Disconnect();
m_TCPClient = null;
}
}
public void Disconnect()
{
if (tCPClient != null)
{
tCPClient.Disconnect();
tCPClient = null;
}
}
public void Disconnect()
{
// Disconnect from the server.
if (_rtpClient != null)
{
_rtpClient.Disconnect();
}
if (_controlClient != null)
{
_controlClient.Disconnect();
}
_disposed = true;
}
public async void SendPacketToServer()
{
INetClient client = await this.ConnectClient();
if (!client.IsConnected)
{
throw new EtherDisconnectedException();
}
// TODO Send packet and wait for answer
client.Disconnect();
}
public void Update()
{
if (client != null)
{
for (Packet packet = client.GetPacket(); packet != null; packet = client.GetPacket())
{
PacketType packetType = packet.BeginRead();
EndPoint remote = null;
switch (type)
{
case ProtocolType.Tcp:
{
if (((Socket)packet.peer).Connected)
{
remote = ((Socket)packet.peer).RemoteEndPoint;
}
else
{
remote = new IPEndPoint(IPAddress.Any, 0);
}
break;
}
case ProtocolType.Udp:
{
remote = (EndPoint)packet.peer;
break;
}
}
if (listener != null)
{
switch (packetType)
{
case PacketType.CONNECT_SUCCESSFUL:
{
client.ConnectSuccessful(packet);
linkstate = LinkCobe.Connect;
listener.OnStatusChanged(linkstate);
break;
}
case PacketType.CONNECTION_LOST:
{
listener.DebugReturn(packet.state.ToString());
linkstate = LinkCobe.Lost;
listener.OnStatusChanged(linkstate);
client.Disconnect();
break;
}
case PacketType.CONNECTION_ATTEMPT_FAILED:
{
listener.DebugReturn(packet.state.ToString());
linkstate = LinkCobe.Failed;
listener.OnStatusChanged(linkstate);
client.Disconnect();
break;
}
case PacketType.ServerTell:
{
if (!string.IsNullOrEmpty(Key))
{
SendData sendData = packet.ReadSendData(Key);
listener.OnEvent(sendData);
}
break;
}
case PacketType.Response:
{
if (!string.IsNullOrEmpty(Key))
{
SendData sendData = packet.ReadSendData(Key);
listener.OnOperationResponse(sendData);
}
break;
}
case PacketType.P2P_CONNECT_SUCCESSFUL:
{
if (!P2PToPeer.ContainsKey(remote))
{
listener.DebugReturn("P2PConnectSuccess: " + remote.ToString());
client.P2PConnectSuccessful(listener.P2PAddPeer, packet);
}
break;
}
case PacketType.P2P_CONNECTION_LOST:
{
if (P2PToPeer.ContainsKey(remote))
{
PeerForP2PBase peer = P2PToPeer[remote];
listener.DebugReturn("P2PConnectLost:" + remote.ToString() + ", error: " + packet.state);
peer.OnDisconnect();
client.P2PDisconnect(packet.peer);
peer = null;
}
break;
}
case PacketType.P2P_Tell:
{
if (P2PToPeer.ContainsKey(remote))
{
PeerForP2PBase peer = P2PToPeer[remote];
SendData sendData = packet.ReadSendData(client.P2PSocketToKey[remote]);
peer.OnGetData(sendData);
}
break;
}
}
}
packet.CloseStream();
}
}
}
