/// <summary> /// Disconnects the user from the server. /// </summary> /// <returns>True if the user is disconnected from the server.</returns> public async Task <bool> SignOut() { if (_state == State.NOT_CONNECTED || _state == State.SIGNING_OUT) { return(true); } if (_hangingGetSocket != null) { _hangingGetSocket.Dispose(); _hangingGetSocket = null; } _state = State.SIGNING_OUT; if (_myId != -1) { await ControlSocketRequestAsync(string.Format( "GET /sign_out?peer_id={0} HTTP/1.0\r\nHost: {1}\r\n\r\n", _myId, _server)) .ConfigureAwait(false); } else { // Can occur if the app is closed before we finish connecting return(true); } _myId = -1; _state = State.NOT_CONNECTED; return(true); }
/// <summary> /// Called when a connection attempt complete, successfully or not. /// !!! NOTE These do not arrive on the main Unity Thread. Most Unity operations will throw in the callback !!! /// </summary> /// <param name="asyncInfo">Data about the async operation.</param> /// <param name="status">The status of the operation.</param> public void NetworkConnectedHandler(IAsyncAction asyncInfo, AsyncStatus status) { // Status completed is successful. if (status == AsyncStatus.Completed) { DataWriter networkDataWriter; // Since we are connected, we can send the data we set aside when establishing the connection. using (networkDataWriter = new DataWriter(networkConnection.OutputStream)) { // Write how much data we are sending. networkDataWriter.WriteInt32(nextDataBufferToSend.Length); // Then write the data. networkDataWriter.WriteBytes(nextDataBufferToSend); // Again, this is an async operation, so we'll set a callback. DataWriterStoreOperation dswo = networkDataWriter.StoreAsync(); dswo.Completed = new AsyncOperationCompletedHandler <uint>(DataSentHandler); } } else { Debug.Log("Failed to establish connection. Error Code: " + asyncInfo.ErrorCode); // In the failure case we'll requeue the data and wait before trying again. networkConnection.Dispose(); // Didn't send, so requeue the data. dataQueue.Enqueue(nextDataBufferToSend); // And set the defer time so the update loop can do the 'Unity things' // on the main Unity thread. deferTime = timeToDeferFailedConnections; } }
protected override void Abort(int traceEventType, string timeoutErrorString, TransferOperation transferOperation) { lock (ThisLock) { if (_closeState == CloseState.Closed) { return; } _timeoutErrorString = timeoutErrorString; _timeoutErrorTransferOperation = transferOperation; _aborted = true; _closeState = CloseState.Closed; if (_asyncReadPending) { CancelReceiveTimer(); } else { this.ReturnReadBuffer(); } if (_asyncWritePending) { CancelSendTimer(); } } _socket.Dispose(); }
// Only included if HoloLens #if !UNITY_EDITOR && UNITY_WSA_10_0 /// <summary> /// Called when the async action is completed (establishing a connection within SendMesh(string networkConfig)) /// If connection is successful, write the Room Mesh data from the Database to the network connection /// If connection is unsuccessful, dispose of the client (StreamSocket) /// </summary> /// <param name="asyncInfo">Information about the async action</param> /// <param name="status">The current status of the async action</param> public void NetworkConnectedHandler(IAsyncAction asyncInfo, AsyncStatus status) { //Debug.Log("YOU CONNECTED TO: " + networkConnection.Information.RemoteAddress.ToString()); // Status completed is successful. if (status == AsyncStatus.Completed) { Debug.Log("PREPARING TO WRITE DATA..."); DataWriter networkDataWriter; // Since we are connected, we can send the data we set aside when establishing the connection. using (networkDataWriter = new DataWriter(holoClient.OutputStream)) { Debug.Log("PREPARING TO WRITE DATA"); // Then write the data. // networkDataWriter.WriteBytes(Database.GetMeshAsBytes()); // Again, this is an async operation, so we'll set a callback. DataWriterStoreOperation dswo = networkDataWriter.StoreAsync(); dswo.Completed = new AsyncOperationCompletedHandler <uint>(DataSentHandler); } } else { Debug.LogWarning("Failed to establish connection. Error Code: " + asyncInfo.ErrorCode); // In the failure case we'll requeue the data and wait before trying again. holoClient.Dispose(); } }
public async Task connectWithServer(string hostName, string port) { if (connected) { _status += "Already connected"; return; } try { _status = "Trying to connect ..."; serverHost = new HostName(hostName); await clientSocket.ConnectAsync(serverHost, port); connected = true; _status = "Connection established"; } catch (Exception exception) { if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) { throw; } _status += "Connect failed with error: " + exception.Message; clientSocket.Dispose(); clientSocket = null; } }
/// <summary> /// Connects this instance. /// </summary> /// <returns>Task.</returns> public async Task Connect() { if (_socket != null) { _socket.Dispose(); } try { _socket = new StreamSocket(); await _socket.ConnectAsync(_device.HostName, _device.ServiceName); //return true; } catch //(Exception ex) { if (_socket != null) { _socket.Dispose(); _socket = null; } throw; } }
public void Close() { _streamWatcher.DataAvailible -= StreamWatcherOnDataAvailible; _streamWatcher.Stop(); _streamWatcher = null; _socket.Dispose(); }
private void DisconnectSender() { if (sender != null) { sender.Dispose(); sender = null; } }
public void NetworkConnectedHandler(IAsyncAction asyncInfo, AsyncStatus status) { DataWriter networkDataWriter; // Status completed is successful. if (status == AsyncStatus.Completed) { // Since we are connected, we can send the data we set aside when establishing the connection. using (networkDataWriter = new DataWriter(socket2.OutputStream)) { Debug.Log("Sending " + stringToSend + " to " + strhostname + " at port " + strport); //networkDataWriter.WriteUInt32(networkDataWriter.MeasureString(stringToSend)); //networkDataWriter.WriteString(stringToSend); if (stringToSend == "1") { networkDataWriter.WriteByte(1); } else if (stringToSend == "2") { networkDataWriter.WriteByte(2); } else if (stringToSend == "3") { networkDataWriter.WriteByte(3); } else if (stringToSend == "4") { networkDataWriter.WriteByte(4); } else if (stringToSend == "5") { networkDataWriter.WriteByte(5); } //networkDataWriter.WriteByte(valuetosend); // Again, this is an async operation, so we'll set a callback. try { DataWriterStoreOperation dswo = networkDataWriter.StoreAsync(); dswo.Completed = new AsyncOperationCompletedHandler <uint>(DataSentHandler); Debug.Log("NetworkConnectedHandler ::Sending"); } catch (Exception exception) { Debug.Log("Store async exception"); } } } else { Debug.Log("Failed to establish connection. Error Code: " + asyncInfo.ErrorCode); // In the failure case we'll requeue the data and wait before trying again. socket2.Dispose(); } }
/// <inheritdoc /> public void Stop() { _streamTcs?.TrySetCanceled(); _streamTcs = null; _tokenRegistration.Dispose(); _listener.ConnectionReceived -= OnConnectionReceived; _listener.Dispose(); _socket?.Dispose(); _socket = null; }
async private void ConnectDevice_Click(object sender, RoutedEventArgs e) { //Revision: No need to requery for Device Information as we alraedy have it: DeviceInformation DeviceInfo; // = await DeviceInformation.CreateFromIdAsync(this.TxtBlock_SelectedID.Text); PairedDeviceInfo pairedDevice = (PairedDeviceInfo)ConnectDevices.SelectedItem; DeviceInfo = pairedDevice.DeviceInfo; bool success = true; try { _service = await RfcommDeviceService.FromIdAsync(DeviceInfo.Id); if (_socket != null) { // Disposing the socket with close it and release all resources associated with the socket _socket.Dispose(); } _socket = new StreamSocket(); try { // Note: If either parameter is null or empty, the call will throw an exception await _socket.ConnectAsync(_service.ConnectionHostName, _service.ConnectionServiceName); } catch (Exception ex) { success = false; System.Diagnostics.Debug.WriteLine("Connect:" + ex.Message); } // If the connection was successful, the RemoteAddress field will be populated if (success) { this.buttonDisconnect.IsEnabled = true; this.buttonSend.IsEnabled = true; this.buttonStartRecv.IsEnabled = true; this.buttonStartProcess.IsEnabled = true; this.buttonStopRecv.IsEnabled = false; this.StartStopReceive.IsEnabled = true; string msg = String.Format("Connected to {0}!", _socket.Information.RemoteAddress.DisplayName); //MessageDialog md = new MessageDialog(msg, Title); System.Diagnostics.Debug.WriteLine(msg); //await md.ShowAsync(); } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("Overall Connect: " + ex.Message); _socket.Dispose(); _socket = null; } }
public override void Close() { if (!IsClosed) { base.Close(); try { iS.Dispose(); } catch (Exception) { } try { oS.Dispose(); } catch (Exception) { } try { streamSocket.Dispose(); } catch (Exception) { } Log(Level.Info, "Closed."); } }
internal async Task <IBuffer> ReadAndCloseAsync(uint dataLength) { IBuffer buffer = new Windows.Storage.Streams.Buffer(dataLength); await dataStreamSocket.InputStream.ReadAsync(buffer, dataLength, InputStreamOptions.None); dataStreamSocket.Dispose(); dataStreamSocket = null; return(buffer); }
private async void TCPConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { StreamSocket socket = args.Socket; DataReader reader = new DataReader(socket.InputStream); try { while (true) { uint MessageSize = await reader.LoadAsync(sizeof(uint)); if (MessageSize != sizeof(uint)) { // socket was closed reader.Dispose(); socket.Dispose(); return; } uint dataLength = reader.ReadUInt32(); byte[] data = new byte[dataLength]; uint actualLength = await reader.LoadAsync(dataLength); if (dataLength != actualLength) { // socket was closed reader.Dispose(); socket.Dispose(); return; } reader.ReadBytes(data); // TODO: Most packets sent won't require a response and won't need to be awaited, which blocks the port // consider using a different port with a different handler for those that do. // For those that don't require a response, simply invoke the callback function and move on. if (_tcpCallback != null) { byte[] response = await _tcpCallback(socket, data); await sendTCPData(socket, response); } } } catch (Exception e) { if (SocketError.GetStatus(e.HResult) == SocketErrorStatus.Unknown) { throw; } } socket.Dispose(); reader.Dispose(); }
public void Disconnect() { if (_controlChannelSocket != null) { _controlChannelSocket.Dispose(); _controlChannelSocket = null; } if (_dataChannelSocket != null) { _dataChannelSocket.Dispose(); _dataChannelSocket = null; } }
private async Task Stop() { if (socket != null) { socket.Dispose(); socket = null; } deviceList.Enabled = true; refreshButton.Enabled = true; connectButton.Enabled = false; closeButton.Enabled = false; sendButton.Enabled = false; await LoadDeviceList().ConfigureAwait(true); }
private async void Button_Click(object sender, RoutedEventArgs e) { //OutBuff = new Windows.Storage.Streams.Buffer(100); Button button = (Button)sender; if (button != null) { switch ((string)button.Content) { case "Disconnect": await this._socket.CancelIOAsync(); _socket.Dispose(); _socket = null; //this.textBlockBTName.Text = ""; //this.TxtBlock_SelectedID.Text = ""; this.buttonDisconnect.IsEnabled = false; this.buttonSend.IsEnabled = false; this.buttonStartRecv.IsEnabled = false; this.buttonStopRecv.IsEnabled = false; break; //case "Send": // //await _socket.OutputStream.WriteAsync(OutBuff); // Send(this.textBoxSendText.Text); // // this.textBoxSendText.Text = ""; // break; //case "Clear Send": // // this.textBoxRecvdText.Text = ""; // break; case "Start Recv": this.buttonStartRecv.IsEnabled = false; this.buttonStopRecv.IsEnabled = true; Listen(); break; case "Stop Recv": this.buttonStartRecv.IsEnabled = false; this.buttonStopRecv.IsEnabled = false; CancelReadTask(); break; case "Refresh": InitializeRfcommDeviceService(); break; } } }
private async void Disconnect() { if (_rfcommProvider != null) { _rfcommProvider.StopAdvertising(); _rfcommProvider = null; } if (_socketListener != null) { _socketListener.Dispose(); _socketListener = null; } if (_writer != null) { _writer.DetachStream(); _writer = null; } if (_socket != null) { _socket.Dispose(); _socket = null; } await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { ListenButton.IsEnabled = true; DisconnectButton.IsEnabled = false; ConversationListBox.Items.Clear(); }); }
public void Dispose() { _writer?.Dispose(); _writer = null; _tcpSocket?.Dispose(); _tcpSocket = null; }
/// <summary> /// Cleans up the socket and DataWriter and reset the UI /// </summary> /// <param name="disconnectReason"></param> private void Disconnect(string disconnectReason) { if (chatWriter != null) { chatWriter.DetachStream(); chatWriter = null; } if (chatService != null) { chatService.Dispose(); chatService = null; } lock (this) { if (chatSocket != null) { chatSocket.Dispose(); chatSocket = null; } } rootPage.NotifyUser(disconnectReason, NotifyType.StatusMessage); ResetUI(); }
public void ClientClose() { if (client != null) { client.Dispose(); } }
public async Task <bool> Close() { await Task.Run(() => ClientSocket.Dispose()); _Status = BrokerConnectionStatus.Disconnected; return(true); }
public async Task Connect(PeerInformation peer) { StreamSocket socket = null; BinaryWriter writer = null; Disconnect(); try { socket = new StreamSocket(); await socket.ConnectAsync(peer.HostName, "{00001101-0000-1000-8000-00805f9b34fb}"); writer = new BinaryWriter(socket.OutputStream.AsStreamForWrite()); Socket = socket; Writer = writer; Peer = peer; } catch (Exception e) { writer?.Dispose(); writer = null; socket?.Dispose(); socket = null; throw; } }
public async Task <EchoResult> CloseAsync() { if (tcpSocket != null) { await tcpDw.FlushAsync(); tcpDw.Dispose(); tcpSocket.Dispose(); tcpSocket = null; tcpDw = null; // Wait for the TcpReadTask to finish if (TcpReadTask != null) { await TcpReadTask; } } if (udpSocket != null) //TODO: what other clients need to close their UDP sockets? { udpDw.Dispose(); udpDw = null; udpSocket = null; } return(TcpReadEchoResult); // Not really fully correct. }
private void Disconnect() { if (reader != null) { reader.DetachStream(); reader.Dispose(); reader = null; } if (writer != null) { writer.DetachStream(); writer.Dispose(); writer = null; } if (socket != null) { lock (this) { socket.Dispose(); } socket = null; } BTService = null; BTDevice = null; DeviceInfoCollection = null; }
public override void Disconnect() { if (_writer != null) { _writer.DetachStream(); _writer = null; } if (_deviceService != null) { _deviceService.Dispose(); _deviceService = null; } lock (this) { if (_socket != null) { _socket.Dispose(); _socket = null; } } ConnectCommand.Enabled = true; }
private void CloseConnection(bool continueAdvertise) { if (_dataReader != null) { _dataReader.Dispose(); _dataReader = null; } if (_dataWriter != null) { _dataWriter.Dispose(); _dataWriter = null; } if (_socket != null) { _socket.Dispose(); _socket = null; } if (continueAdvertise) { // Since there is no connection, let's advertise ourselves again, so that peers can find us. PeerFinder.Start(); } else { PeerFinder.Stop(); } }
public void Disconnect() { Listening = false; if (provider != null) { if (isAdvertising) { provider.StopAdvertising(); } provider = null; } // StopAdvertising relentlessly causes a crash if not advertising. if (socketListener != null) { socketListener.Dispose(); socketListener = null; } if (writer != null) { writer.DetachStream(); writer.Dispose(); writer = null; } if (reader != null) { reader.DetachStream(); reader.Dispose(); reader = null; } if (socket != null) { socket.Dispose(); socket = null; } if (listeningTask != null) { listeningTask = null; } }
private async void requestError(DataWriter writer, StreamSocket socket, string status, string message = "") { writer.WriteString("HTTP/1.0 " + status + "\r\nContent-Type: text/plain\r\nConnection: close\r\n\r\n" + message); await writer.StoreAsync(); socket.Dispose(); }
private async void ConnectToDevice(PeerInformation peer) { if (_socket != null) { // Disposing the socket with close it and release all resources associated with the socket _socket.Dispose(); } try { _socket = new StreamSocket(); string serviceName = (String.IsNullOrWhiteSpace(peer.ServiceName)) ? tbServiceName.Text : peer.ServiceName; // Note: If either parameter is null or empty, the call will throw an exception await _socket.ConnectAsync(peer.HostName, serviceName); // If the connection was successful, the RemoteAddress field will be populated MessageBox.Show(String.Format(AppResources.Msg_ConnectedTo, _socket.Information.RemoteAddress.DisplayName)); } catch (Exception ex) { // In a real app, you would want to take action dependent on the type of // exception that occurred. MessageBox.Show(ex.Message); _socket.Dispose(); _socket = null; } }