private async void ConnectionBegunCallback(IAsyncResult asyncResult)
{
try
{
var client = (TcpClient)asyncResult.AsyncState;
client.EndConnect(asyncResult);
_currentUser.NetworkStream = client.GetStream();
if (_currentUser.NetworkStream == null)
{
_connectionFailedCallback.Invoke();
return;
}
var msg = new ConnectRequestMessage {
ChatEnterMessage = "Hello", UserId = (ushort)_currentUser.Id
};
await _networkDataService.WriteAndEncodeMessageWithHeader(msg, _currentUser.NetworkStream);
_connectionSuccseful.Invoke();
}
catch (Exception)
{
if (_connectionFailedCallback == null)
{
throw new Exception("No failed connection callback set.");
}
_connectionFailedCallback.Invoke();
}
}
protected void SendConnect(string clientId,
ITransportConnection connection)
{
var message = new ConnectRequestMessage(clientId: clientId,
connectionType: ONLY_SUPPORTED_CONNECTION_TYPE,
id: MessageCounter++);
var json = Converter.Serialize(message);
connection.Send(json);
}
public static async Task <SmartGlassClient> ConnectAsync(
string addressOrHostname, string xboxLiveUserHash, string xboxLiveAuthorization)
{
var device = await Device.PingAsync(addressOrHostname);
var cryptoContext = new CryptoContext(device.Certificate);
using (var transport = new MessageTransport(device.Address.ToString(), cryptoContext))
{
var deviceId = Guid.NewGuid();
var sequenceNumber = 0u;
var initVector = CryptoContext.GenerateRandomInitVector();
Func <Task> connectFunc = async() =>
{
var requestMessage = new ConnectRequestMessage();
requestMessage.InitVector = initVector;
requestMessage.DeviceId = deviceId;
requestMessage.UserHash = xboxLiveUserHash;
requestMessage.Authorization = xboxLiveAuthorization;
requestMessage.SequenceNumber = sequenceNumber;
requestMessage.SequenceBegin = sequenceNumber + 1;
requestMessage.SequenceEnd = sequenceNumber + 1;
sequenceNumber += 2;
await transport.SendAsync(requestMessage);
};
var response = await TaskExtensions.WithRetries(() =>
transport.WaitForMessageAsync <ConnectResponseMessage>(
connectTimeout,
() => connectFunc().Wait()),
connectRetries);
return(new SmartGlassClient(
device,
response,
cryptoContext));
}
}
/// <summary>
/// Connect to a discovered console
/// </summary>
/// <param name="device">Discovered, available console</param>
/// <param name="xboxLiveUserHash">Xbox Live userhash (uhs)</param>
/// <param name="xboxLiveAuthorization">Xbox Live authorization token (XToken)</param>
/// <returns></returns>
public static async Task <SmartGlassClient> ConnectAsync(
Device device, string xboxLiveUserHash, string xboxLiveAuthorization)
{
bool connectAuthenticated = !String.IsNullOrEmpty(xboxLiveUserHash) &&
!String.IsNullOrEmpty(xboxLiveAuthorization);
if (device.State == DeviceState.Unavailable)
{
throw new SmartGlassException("Target device state is 'Unavailable'.");
}
else if (!connectAuthenticated && !device.Flags.HasFlag(DeviceFlags.AllowAnonymousUsers))
{
throw new SmartGlassException("Anonymous connection forbidden.");
}
var cryptoContext = new CryptoContext(device.Certificate);
ConnectResponseMessage response;
using (var transport = new MessageTransport(device.Address.ToString(), cryptoContext))
{
Guid deviceId = Guid.NewGuid();
async Task connectFunc()
{
foreach (var fragment in ConnectRequestMessage
.GenerateConnectRequest(deviceId, cryptoContext, xboxLiveUserHash, xboxLiveAuthorization))
{
await transport.SendAsync(fragment);
}
}
response = await Common.TaskExtensions.WithRetries(() =>
transport.WaitForMessageAsync <ConnectResponseMessage>(
connectTimeout,
connectFunc),
connectRetries);
}
var client = new SmartGlassClient(
device,
response,
cryptoContext);
await client._InitTask;
return(client);
}
public async Task <IMessage> ReadAndDecodeMessage(Header header, NetworkStream networkStream)
{
byte[] dataBuffer = new byte[header.MessageSize];
await networkStream.ReadAsync(dataBuffer, 0, dataBuffer.Length);
Console.WriteLine("message type being read in network service: " + header.MessageType);
var dataBufferList = dataBuffer.ToList();
switch (header.MessageType)
{
case MessageType.NotSet:
return(null);
case MessageType.Connect:
return(ConnectRequestMessage.Decode(dataBufferList));
case MessageType.Chat:
return(ChatMessage.Decode(dataBufferList));
case MessageType.Image:
return(ImageMessage.Decode(dataBufferList));
case MessageType.NewUserOnline:
return(NewUserOnlineMessage.Decode(dataBufferList));
case MessageType.UserLogoff:
return(UserLogoffMessage.Decode(dataBufferList));
case MessageType.UserOffline:
return(UserOfflineMessage.Decode(dataBufferList));
case MessageType.Typing:
return(UserTypingMessage.Decode(dataBufferList));
default:
throw new ArgumentOutOfRangeException();
}
}
private static async Task <Tuple <int, NetworkStream> > SetupClient(string ip)
{
var client = new TcpClient();
client.Connect(new IPEndPoint(IPAddress.Parse("172.30.142.49"), 2500));
var random = new Random();
var stream = client.GetStream();
var msg = new ConnectRequestMessage()
{
UserId = 7,
ChatEnterMessage = "Hello"
};
await service.WriteAndEncodeMessageWithHeader(msg, stream);
BeginListening(stream);
return(new Tuple <int, NetworkStream>(msg.UserId, stream));
}
public bool TryAcceptNewPlayer(ConnectRequestMessage connectRequestMessage, out ConnectResponseMessage responseMessage)
{
throw new NotImplementedException();
}
