/// <summary> /// Restores session or tries to establish a new one. /// Invokes <see cref="OnConnectionSuccess"/> or <see cref="OnConnectionFailure"/>. /// </summary> /// <returns></returns> public async Task <AuthenticationResponse> ConnectAsync() { AuthenticationResponse response = await RestoreTokenAsync(); switch (response) { case AuthenticationResponse.Authenticated: OnConnectionSuccess?.Invoke(); break; case AuthenticationResponse.NewAccountCreated: OnNewAccountCreated?.Invoke(); OnConnectionSuccess?.Invoke(); break; case AuthenticationResponse.Error: OnConnectionFailure?.Invoke(); break; default: Debug.LogError("Unhandled response received: " + response); break; } return(response); }
public void Connect(IPEndPoint hostEndpoint, OnConnectionEstablished onConnectionEstablished = null, OnConnectionFailure onConnectionFailure = null, OnDisconnected onDisconnected = null) { var connectionId = _transporter.Connect(hostEndpoint); _connections[connectionId] = new ConnectionRegistration { OnConnectionEstablished = onConnectionEstablished ?? EmptyOnConnectionEstablished, OnDisconnected = onDisconnected ?? EmptyOnDisconnected }; }
public ConnectionId Connect(IPEndPoint hostEndpoint, ApprovalSecret approvalSecret, OnConnectionEstablished onConnectionEstablished = null, OnConnectionFailure onConnectionFailure = null, OnDisconnected onDisconnected = null) { var connectionId = _connectionIdPool.Take(); _transporter.Connect(connectionId, approvalSecret, hostEndpoint); _connections[connectionId] = new ConnectionRegistration { Endpoint = hostEndpoint, OnConnectionEstablished = onConnectionEstablished ?? EmptyOnConnectionEstablished, OnConnectionFailure = onConnectionFailure ?? EmptyOnConnectionFailure, OnDisconnected = onDisconnected ?? EmptyOnDisconnected, Status = ConnectionStatus.Pending, }; return(connectionId); }
public void Connect(IPEndPoint hostEndpoint, OnConnectionEstablished onConnectionEstablished = null, OnConnectionFailure onConnectionFailure = null, OnDisconnected onDisconnected = null) { var connectionRegistration = new ConnectionRegistration(); connectionRegistration.Timestamp = Time.realtimeSinceStartup; connectionRegistration.ConnectionId = ConnectionId.NoConnection; connectionRegistration.PublicEndpoint = hostEndpoint; connectionRegistration.OnConnectionEstablished = onConnectionEstablished ?? EmptyOnConnectionEstablished; connectionRegistration.OnConnectionFailure = onConnectionFailure ?? EmptyOnConnectionFailure; connectionRegistration.OnDisconnected = onDisconnected ?? EmptyOnDisconnected; var punchId = _natPunchClient.Punch(hostEndpoint, OnPunchSuccess, OnPunchFailure); _punchAttempts.Add(punchId, connectionRegistration); }
public void JoinServer(IPEndPoint endPoint, int clientPort = -1, OnConnectionEstablished onEstablished = null, OnConnectionFailure onFailure = null, OnDisconnected onDisconnected = null) { Shutdown(); _isJoinInProgress = true; _isSingleplayer = false; _coroutineScheduler.Run(_networkClient.Join(endPoint, clientPort, (connectionId, endpoint) => { _authorityConnectionId = connectionId; _isJoinInProgress = false; if (onEstablished != null) { onEstablished(connectionId, endPoint); } }, onFailure, onDisconnected)); }
public ConnectionId Connect(IPEndPoint hostEndpoint, ApprovalSecret approvalSecret, OnConnectionEstablished onConnectionEstablished = null, OnConnectionFailure onConnectionFailure = null, OnDisconnected onDisconnected = null) { var connectionId = _connectionIdPool.Take(); var connectionRegistration = _connectionRegistrationPool.Take(); connectionRegistration.Instance.Timestamp = Time.realtimeSinceStartup; connectionRegistration.Instance.ConnectionId = connectionId; connectionRegistration.Instance.ApprovalSecret = approvalSecret; connectionRegistration.Instance.PublicEndpoint = hostEndpoint; connectionRegistration.Instance.OnConnectionEstablished = onConnectionEstablished ?? EmptyOnConnectionEstablished; connectionRegistration.Instance.OnConnectionFailure = onConnectionFailure ?? EmptyOnConnectionFailure; connectionRegistration.Instance.OnDisconnected = onDisconnected ?? EmptyOnDisconnected; var punchId = _natPunchClient.Punch(hostEndpoint, OnPunchSuccess, OnPunchFailure); _punchAttempts.Add(punchId, connectionRegistration); return(connectionId); }
private void OnSteamClientConnected(SteamClient.ConnectedCallback callback) { if (callback.Result != EResult.OK) { OnConnectionFailure?.Invoke(this, string.Format("Unable to connect to Steam: {0}", callback.Result)); Disconnect(); return; } OnConnectionSuccess?.Invoke(this, string.Format("Connected to Steam! Logging in '{0}'...", m_SteamUserName)); byte[] sentryHash = null; if (File.Exists(Settings.Default.SentryFileLocation)) { // if we have a saved sentry file, read and sha-1 hash it byte[] sentryFile = File.ReadAllBytes(Settings.Default.SentryFileLocation); sentryHash = CryptoHelper.SHAHash(sentryFile); } m_steamUser.LogOn(new SteamUser.LogOnDetails { Username = m_SteamUserName, Password = m_SteamPassword.ToPlainText(), // this value will be null (which is the default) for our first logon attempt AuthCode = m_AuthCode, // if the account is using 2-factor auth, we'll provide the two factor code instead // this will also be null on our first logon attempt TwoFactorCode = m_TwoFactorAuth, // our subsequent logons use the hash of the sentry file as proof of ownership of the file // this will also be null for our first (no authcode) and second (authcode only) logon attempts SentryFileHash = sentryHash, }); }
public void Connect(IPEndPoint remoteEndPoint, OnConnectionEstablished onEstablished, OnConnectionFailure onFailure, OnDisconnected onDisconnected) { _ramnet.MessageRouter.ClearHandlers(); _ramnet.MessageRouter .RegisterHandler <BasicMessage.Pong>(OnServerClockSync) .RegisterHandler <BasicMessage.ReplicatePreExistingObject>((connectionId, endpoint, message) => { Debug.Log("replicating existing instance " + message.GlobalObjectId); var instance = _ramnet.PreExistingObjects[message.GlobalObjectId]; Debug.Log("instance found: " + instance); _ramnet.ReplicatedObjectStore.ReplicateExistingInstance(message.ObjectRole, connectionId, instance, message.NetworkObjectId, message.GlobalObjectId); }) .RegisterHandler <BasicMessage.CreateObject>((connectionId, endpoint, message, reader) => { var replicatedObject = _ramnet.ReplicatedObjectStore.AddReplicatedInstance( message.ObjectType, message.ObjectRole, message.ObjectId, connectionId); Debug.Log("Creating object with id " + message.ObjectId, replicatedObject.GameObject); _ramnet.ReplicatedObjectStore.DispatchMessages(connectionId, message.ObjectId, message.AdditionalData, message.AdditionalData.LengthBytes); replicatedObject.Activate(); if (message.ObjectType == ObjectTypes.Player && message.ObjectRole.IsOwner()) { _camera.Target = replicatedObject.GameObject.GetComponent <PlayerSimulation>(); } }) .RegisterHandler <BasicMessage.ToObject>((connectionId, endpoint, message, reader) => { _ramnet.ReplicatedObjectStore.DispatchMessage(connectionId, message.ReceiverId, reader); }) .RegisterHandler <BasicMessage.DeleteObject>((connectionId, endpoint, message, reader) => { _ramnet.ReplicatedObjectStore.RemoveReplicatedInstance(connectionId, message.ObjectId); }); _ramnet.GroupRouter.ClearConnectionHandlers(); if (_transporter.Status == TransporterStatus.Closed) { var transportConfig = new NetPeerConfiguration("RigidbodyParty"); transportConfig.MaximumConnections = 64; _transporter.Open(transportConfig); } Debug.Log("Connecting to " + remoteEndPoint); _initialSyncDone = false; _ramnet.ConnectionManager.Connect(remoteEndPoint, (connId, endpoint) => { OnConnectionEstablished(connId, endpoint); onEstablished(connId, endpoint); }, (endpoint, exception) => { OnConnectionFailure(endpoint); onFailure(endpoint, exception); }, connId => { OnDisconnected(connId); onDisconnected(connId); }); _camera.gameObject.SetActive(true); }
public IEnumerator <WaitCommand> Join(IPEndPoint endPoint, int clientPort = -1, OnConnectionEstablished onEstablished = null, OnConnectionFailure onFailure = null, OnDisconnected onDisconnected = null) { _outstandingPings.Clear(); _frameId = 0; _isJoinInProgress = true; var sessionIdResult = new AsyncResult <JoinResponse>(); string password = null; _masterServerClient.Client.Join(endPoint, password, (statusCode, s) => { sessionIdResult.SetResult(s); }); while (!sessionIdResult.IsResultAvailable) { yield return(WaitCommand.WaitForNextFrame); } if (sessionIdResult.Result != null) { _sessionId = sessionIdResult.Result.SessionId; var netConfig = new NetPeerConfiguration(NetworkConfig.GameId); // Kind of arbitrary, we need to have enough room for connection attempts // and cancellation running simultaneously but we don't need to have an unlimited number netConfig.MaximumConnections = 16; if (clientPort > -1) { netConfig.Port = clientPort; } _transporter.Open(netConfig); var approvalSecret = new ApprovalSecret(_sessionId.Value.Value); _hostConnectionId = _networkSystems.ConnectionManager.Connect(endPoint, approvalSecret, (connId, endpoint) => { _isJoinInProgress = false; OnConnectionEstablished(connId, endpoint); if (onEstablished != null) { onEstablished(connId, endpoint); } }, (endpoint, exception) => { _isJoinInProgress = false; OnConnectionFailure(endpoint, exception); if (onFailure != null) { onFailure(endpoint, exception); } }, connId => { _isJoinInProgress = false; OnDisconnected(connId); if (onDisconnected != null) { onDisconnected(connId); } }); } else { OnConnectionFailure(endPoint, new Exception("Master server did not allow join on " + endPoint)); } }
public virtual void Connect(BTPeer peer, int numberOfRetries = 5) { Task.Run(async() => { try { socket = peer.Device.CreateRfcommSocketToServiceRecord(BluetoothServer.ServiceUUID); await Task.Delay(100); socket.Connect(); await Task.Delay(250); if (socket.IsConnected) { Log.Debug(_tag, $"Client: Connection accepted to {socket.RemoteDevice.Address}."); OnConnectionSuccess?.Invoke(this, EventArgs.Empty); IsConnected = true; } else { OnConnectionFailure?.Invoke(this, EventArgs.Empty); IsConnected = false; if (numberOfRetries > 0) { Log.Debug(_tag, $"Client: Connection unsuccessful; retrying in {SocketTimeout} ms."); await Task.Delay(SocketTimeout) .ContinueWith((_) => { Connect(peer, numberOfRetries - 1); }) .ConfigureAwait(false); } else { Log.Debug(_tag, "Client: Connection unsuccessful, retry limit exhausted."); } return; } inStream = new DataInputStream(socket.InputStream); outStream = new DataOutputStream(socket.OutputStream); BluetoothCore.RunSendingLooper(this); Task.Delay(500) .ContinueWith(_ => SendMessage(new Message(MsgType.Notify, $"{CONFIRM_AS_CLIENT}{NEXT}{socket.RemoteDevice.Address}"))) .LaunchAsOrphan(); //await Task.Delay(100); var ListeningLoop = Task.Run((Action)Listen); // When finished, *should* mean that it's received its stop signal and is thus ready to close. //foreach (var teammate in HeyYou.MyTeammates.TeamMembers) //{ // var teamMate = teammate as CommsContact; // if (teamMate == null) continue; // if (teamMate.IPaddress == socket.RemoteDevice.Address) continue; // Don't bother suggesting themselves as a teammate! // SendMessage(new Message(MsgType.Notify, $"{SUGGEST_TEAMMATE}{NEXT}{teamMate.IPaddress}")); //} await ListeningLoop; } catch (Exception e) { Log.Debug(_tag, e.ToString()); } finally { Log.Debug(_tag, "Closing client connection."); //socket.Close(); //IsConnected = false; Disconnect(); } }); }