async void SendKeepAlive(Object stateInfo) { if (bindedDevice != null && bindedDevice.BindActive == false) { bindedDevice = null; await tcpClient.DisconnectAsync(); return; } else if (keepAliveWatch.ElapsedMilliseconds > 4 * keepAliveTimer) { if (bindedDevice != null) { bindedDevice.BindActive = false; } await tcpClient.DisconnectAsync(); isTcpThreadActive = false; BindDropped(); return; } byte[] msg = Encoding.UTF8.GetBytes("a*\r"); tcpClient.WriteStream.Write(msg, 0, msg.Length); await tcpClient.WriteStream.FlushAsync(); }
public async Task DisconnectAsync() { _shouldBeConnected = false; await _client.DisconnectAsync(); _client = null; }
public void send_text(string src, out int length) { client.ConnectAsync(address_con_to, port[0]); byte[] bytes = (new System.Text.UTF8Encoding()).GetBytes(src); length = bytes.Length; foreach (byte a in bytes) { client.WriteStream.WriteByte(a); client.WriteStream.FlushAsync(); Task.Delay(50); } client.DisconnectAsync(); }
private void Init() { try { mSocket.ConnectAsync(SERVER_ADDRESS, SERVER_PORT); } catch (Exception ex) { mSocket.DisconnectAsync(); } // we're connected! }
/// <summary> /// Disconnects us from the IGS server and closes all IGS games. /// </summary> /// <returns></returns> public async Task DisconnectAsync() { try { await _client.DisconnectAsync(); } catch { // Ignore all TCP errors. } finally { ConnectionLost(); } }
async void SocketButton_Clicked(object sender, EventArgs e) { var address = "10.0.2.2"; var port = 2001; var sendString = $"{Name.Text}," + $"{Product.Text}," + $"{Lot.Text}," + $"{Date.Date.ToString("yyyy/MM/dd")} {Time.Time}\n"; using (var client = new TcpSocketClient()) { try { await client.ConnectAsync(address, port); var enc = Encoding.UTF8; var sendBytes = enc.GetBytes(sendString); foreach (var byteData in sendBytes) { client.WriteStream.WriteByte(byteData); await client.WriteStream.FlushAsync(); } await client.DisconnectAsync(); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.InnerException); } } }
public async Task Send(string ip, int port) { var r = new Random(); RaiseInfoEvent(string.Format("Connecting to: {0}:{1}", ip, port)); _outChannel = new TcpSocketClient(); RaiseOutChannelStarted(true); await _outChannel.ConnectAsync(ip, port); RaiseInfoEvent("We're connected!"); for (int i = 0; i < 5; i++) { // write to the 'WriteStream' property of the socket client to send data var nextByte = (byte)r.Next(0, 254); RaiseInfoEvent(string.Format("Sending: {0}", nextByte)); _outChannel.WriteStream.WriteByte(nextByte); await _outChannel.WriteStream.FlushAsync(); // wait a little before sending the next bit of data await Task.Delay(TimeSpan.FromMilliseconds(500)); } await _outChannel.DisconnectAsync(); RaiseInfoEvent("Message sent!"); RaiseOutChannelStarted(false); IsSending = false; }
private async void TcpServer() { // Send Message Via TCP var address = "255.255.255.255"; var port = 25000; var r = new Random(); var client = new TcpSocketClient(); await client.ConnectAsync(address, port); Debug.WriteLine("we're connected!"); var msg = $"DeviceState: {_product.State} DeviceLevel: {_product.level}"; byte[] toBytes = Encoding.ASCII.GetBytes(msg); // we're connected! try { for (int i = 0; i < toBytes.Length; i++) { // write to the 'WriteStream' property of the socket client to send data client.WriteStream.WriteByte(toBytes[i]); await client.WriteStream.FlushAsync(); // wait a little before sending the next bit of data //await Task.Delay(TimeSpan.FromMilliseconds(500)); } } catch (Exception ex) { Debug.WriteLine(ex.Message); } await client.DisconnectAsync(); }
public async void closeConnection() { //if (isConnected()) //{ await socket.DisconnectAsync(); //} }
public async Task Disconnect() { if (_client != null) { await _client.DisconnectAsync(); } _client = null; }
public void Close() { if (_client != null) { _client.DisconnectAsync().Wait(); } _client = null; _connected = false; }
private async void OnDisConnectClicked(object sender, EventArgs e) { //var bytes = Encoding.UTF8.GetBytes("$"); //await client.WriteStream.WriteAsync(bytes, 0, bytes.Length); //await client.WriteStream.FlushAsync(); await client.WriteStringAsync("Disconnect", "$"); //$ 結束符號 await client.DisconnectAsync(); }
public async Task DisconnectAsync() { IsConnected = false; _receivedMessages.Unmerge(this); _jsonProtocolMessenger.StopExecuting(); await _tcpSocketClient.DisconnectAsync(); _tcpSocketClient = new TcpSocketClient(); }
/// <summary> /// Releases unmanaged and - optionally - managed resources. /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected override async void Dispose(bool disposing) { if (disposing) { if (_client != null) { //_client.Dispose(); await _client.DisconnectAsync(); } } base.Dispose(disposing); }
public async void CreateTCPClient() { try { App.DevPage.devPageActIndicator(true); client = new TcpSocketClient(); await client.ConnectAsync(address, port); TCPConnected(); string finalData = ""; await Task.Run(() => { try { byte[] byteData = new byte[1]; while (client.ReadStream.Read(byteData, 0, 1) != 0) { if (byteData[0] == 0x02) { finalData = ""; } else if (byteData[0] == 0x04) { HandelReceivedData(finalData); finalData = ""; } else { finalData += Convert.ToChar(byteData[0]); } } TCPDisconnected(); } catch (Exception) { TCPDisconnected(); } }); await client.DisconnectAsync(); } catch (Exception e) { client = null; Debug.WriteLine(e.ToString()); TCPDisconnected(); } }
/// <summary> /// Disconnect the current device an dispose all ressources /// </summary> public static async void Disconnect() { connected = false; try { await tcpSocketClient.DisconnectAsync(); tcpSocketClient.Dispose(); } catch (Exception e) { throw new Exception(305, "The device could not disconnect"); } }
private void InitView() { Content = new StackLayout() { Padding = new Thickness(0, Device.OnPlatform(20, 0, 0), 0, 0), Children = { new ClientConnectView("127.0.0.1", 11000, this) { ConnectTapped = async(s, i) => { await _client.ConnectAsync(s, i); _canceller = new CancellationTokenSource(); Task.Factory.StartNew(() => { foreach (var msg in _client.ReadStrings(_canceller.Token)) { _messagesSub.OnNext(msg); } }, TaskCreationOptions.LongRunning); return(true); }, DisconnectTapped = async() => { var bytes = Encoding.UTF8.GetBytes("<EOF>"); await _client.WriteStream.WriteAsync(bytes, 0, bytes.Length); await _client.WriteStream.FlushAsync(); _canceller.Cancel(); await _client.DisconnectAsync(); } }, new MessagesView(_messagesObs, true) { SendData = async s => { await _client.WriteStringAsync(s); return(new Message { Text = s, DetailText = String.Format("Sent at {0}",DateTime.Now.ToString("HH:mm:ss")) }); } } } }; }
protected override async void OnAppearing() { base.OnAppearing(); client = new TcpSocketClient(); try { await client.ConnectAsync("ws://192.168.1.69:81", "tcp"); client.WriteStream.WriteByte(Convert.ToByte("ledon")); await client.WriteStream.FlushAsync(); await client.DisconnectAsync(); } catch { } }
public async void TCPDisconnected() { try { if (client != null) { await client.DisconnectAsync(); } Device.BeginInvokeOnMainThread(() => { App.DevPage.normalSLayout.IsVisible = false; App.DevPage.connectSLayout.IsVisible = true; }); App.streamSendNext = true; } catch (Exception) { throw; } }
public async Task Connect() { var address = "172.24.1.1"; var port = 5050; var r = new Random(); var client = new TcpSocketClient(); await client.ConnectAsync(address, port); // we're connected! for (int i = 0; i < 5; i++) { // write to the 'WriteStream' property of the socket client to send data var nextByte = (byte)r.Next(0, 254); client.WriteStream.WriteByte(nextByte); await client.WriteStream.FlushAsync(); // wait a little before sending the next bit of data await Task.Delay(TimeSpan.FromMilliseconds(500)); } await client.DisconnectAsync(); }
public async Task SendData(string address, int port, string message) { Console.WriteLine("Sending " + message + " to " + address + " at " + port); var client = new TcpSocketClient(); await client.ConnectAsync(address, port); byte[] data = Encoding.ASCII.GetBytes(message); client.WriteStream.Write(data, 0, data.Length); await client.WriteStream.FlushAsync(); // wait a little before sending the next bit of data await Task.Delay(TimeSpan.FromMilliseconds(500)); await client.DisconnectAsync(); }
public async Task Disconnect() { await client.DisconnectAsync(); }
public void CloseConnection() { tcpClient.DisconnectAsync().Wait(); connected = false; }
public async void doSend(Packet sendpacket) { Debug.WriteLine($"PP:doSend {sendpacket.method} {sendpacket.toip} {sendpacket.toport} {sendpacket.ascii}"); // byte[] bytesToSend = System.Text.Encoding.UTF8.GetBytes(sendpacket.ascii); byte[] bytesToSend = sendpacket.getByteArray(); try { sendpacket.error = ""; await tcp.DisconnectAsync(); if (sendpacket.isTCP()) { await tcp.ConnectAsync(sendpacket.toip, sendpacket.toport); await tcp.WriteStream.WriteAsync(bytesToSend, 0, bytesToSend.Length); await tcp.DisconnectAsync(); /* * // wait a little before reading * var bytesRecv = new byte[20]; * //tcp.ReadStream.ReadTimeout = 200; * //not async, so it can time out. * await Task.Delay(TimeSpan.FromMilliseconds(00)); * if (tcp.ReadStream.Length > 0) * { * int bytesRead = await tcp.ReadStream.ReadAsync(bytesRecv, 0, 20); * if (bytesRead > 0) * { * Packet receivepkt = new Packet(); * receivepkt.toip = sendpacket.fromip; * receivepkt.fromip = sendpacket.toip; * receivepkt.fromport = sendpacket.toport; * Array.Resize(ref bytesRecv, bytesRead); * receivepkt.hex = Packet.byteArrayToHex(bytesRecv); * MessagingCenter.Send(this, Events.NEW_TRAFFIC_PACKET, receivepkt); * } * * } */ } if (sendpacket.isUDP()) { await udpServer.SendToAsync(bytesToSend, sendpacket.toip, sendpacket.toport); } } catch (Exception eSend) { sendpacket.error = "Error: " + eSend.Message; Debug.WriteLine("PP:Exception : " + eSend.Message); } Debug.WriteLine("PP:Before Message"); MessagingCenter.Send(this, Events.NEW_TRAFFIC_PACKET, sendpacket); Debug.WriteLine("PP:After Message"); Debug.WriteLine("PP:Finished"); }
public async Task Disconnect() { await _client.DisconnectAsync(); _client = null; }
public Task DisconnectAsync() { return(_client.DisconnectAsync()); }
public async Task StopAsync() { await client.DisconnectAsync(); client.Dispose(); }
private void Button_Click_2(object sender, RoutedEventArgs e) { client.DisconnectAsync(); }
private void Disconnect() { _client.DisconnectAsync(); _isConnected = false; OnServerDisconnected?.Invoke(this, new EventArgs()); }
public async void receiveTCP() { try { bool validMsg = false; bool msgComplete = false; byte[] finalMsg = new byte[1000]; int index_finalMsg = 0; await Task.Run(async() => { try { byte[] byteTCP = new byte[1]; while (client.ReadStream.Read(byteTCP, 0, 1) != 0) { /*determine if the message is valid before doing anything else*/ if (byteTCP[0] == 0x02) { validMsg = true; } else if (byteTCP[0] == 0x04) { msgComplete = true; } /*determine if the message is valid before doing anything else*/ /*save the message if it is valid*/ if (validMsg == true) { finalMsg[index_finalMsg] = byteTCP[0]; index_finalMsg++; } if (msgComplete == true) { validMsg = false; /*Handle the complete message*/ await handleTCPAsync(finalMsg); /*Handle the complete message*/ msgComplete = false; index_finalMsg = 0; finalMsg = new byte[1000]; } /*save the message if it is valid*/ } await client.DisconnectAsync(); Device.BeginInvokeOnMainThread(() => { App.myMainPage.tcpDisconnectedView(); }); } catch (Exception e) { await client.DisconnectAsync(); Device.BeginInvokeOnMainThread(() => { App.myMainPage.tcpDisconnectedView(); }); } }); } catch (Exception e) { await client.DisconnectAsync(); Device.BeginInvokeOnMainThread(() => { App.myMainPage.tcpDisconnectedView(); }); } }