private async void CharacteristicStreamButton_Click(object sender, RoutedEventArgs e)
{
try
{
// Create a client socket and connect to the server.
//Windows.Networking.Sockets.
if (socket == null)
{
socket = new Windows.Networking.Sockets.StreamSocket();
}
// Define the server name and port
Windows.Networking.HostName serverHost = new Windows.Networking.HostName("localhost");
string serverPort = "1337";
// Connect to server
await socket.ConnectAsync(serverHost, serverPort);
// launch the HR data stream routine.
socket.InputStream.AsStreamForRead();
//
// Start listening for incoming TCP connections on the specified port.
}
catch (Exception ex)
{
// This happens when the network socket failed to create
rootPage.NotifyUser(ex.Message, NotifyType.ErrorMessage);
}
}
public static async void SendCommand(string message, string ip)
{
using (var streamSocket = new Windows.Networking.Sockets.StreamSocket())
{
try
{
await streamSocket.ConnectAsync(new HostName(ip), "9999");
using (Stream outputStream = streamSocket.OutputStream.AsStreamForWrite())
{
byte[] encrypted = Encrypt(message);
await outputStream.WriteAsync(encrypted, 0, encrypted.Length);
await outputStream.FlushAsync();
}
}
catch (Exception oops)
{
ContentDialog dialog = new ContentDialog
{
Title = "Communication error",
Content = "The following error occurred while attempting to communicate with the switch:\n\n" + oops.Message,
CloseButtonText = "OK"
};
await dialog.ShowAsync();
}
}
}
private async void connectbutton_ClickAsync(object sender, RoutedEventArgs e)
{
mTimer2.Start();
TextBox TBox = IP;
Ip = TBox.Text;
var settings = ApplicationData.Current.LocalSettings;
settings.Values["IP"] = Ip;
serverDisposed.Visibility = Visibility.Collapsed;
try
{
socket = new Windows.Networking.Sockets.StreamSocket();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName(Ip);
string serverPort = "1337";
await socket.ConnectAsync(serverHost, serverPort);
Stream streamOut = socket.OutputStream.AsStreamForWrite();
Writer = new StreamWriter(streamOut);
VerticalPage verticalpage = frame.Content as VerticalPage;
verticalpage.AppearImg();
//create timer
mTimer.Tick += MTimer_Tick;
mTimer.Interval = TimeSpan.FromSeconds(5);
mTimer.Start();
connectbutton.Visibility = Visibility.Collapsed;
stackPanel.Visibility = Visibility.Collapsed;
serverIP.Visibility = Visibility.Collapsed;
}
catch (Exception ex)
{
}
}
private async void LongListSelector_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
{
List <string> selectedDeviceNames = App.ViewModel
.Settings
.EnabledBuetoothDevicesCanonicalNames
.Where(d => !e.RemovedItems.Cast <BluetoothDeviceViewModel>().Any(ri => ri.CanonicalName.Equals(d, StringComparison.OrdinalIgnoreCase)))
.ToList();
try
{
foreach (var item in e.AddedItems)
{
var bluetoothDevice = item as BluetoothDeviceViewModel;
if (bluetoothDevice == null || selectedDeviceNames.Any(dn => dn.Equals(bluetoothDevice.CanonicalName, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
using (var socket = new Windows.Networking.Sockets.StreamSocket())
await socket.ConnectAsync(new Windows.Networking.HostName(bluetoothDevice.CanonicalName), "{00001101-0000-1000-8000-00805f9b34fb}");
selectedDeviceNames.Add(bluetoothDevice.CanonicalName);
}
}
catch (System.Exception)
{
MessageBox.Show("One or more selected devices do not support the Serial Port Profile and cannot be used");
}
App.ViewModel.Settings.EnabledBuetoothDevicesCanonicalNames = selectedDeviceNames;
}
public void Connect()
{
TvDirectSocket = new Windows.Networking.Sockets.StreamSocket();
TvDirectSocket.ConnectAsync(ConnectedHostName, ConnectedPort.ToString()).Completed += newConnected;
ConnectionState = TvConnectionState.Connecting;
Connecting?.Invoke();
}
public static async Task <XDocument> SockeRequest(
string ip,
string port,
string strReq
)
{
XDocument doc = null;
try
{
var socket = new Windows.Networking.Sockets.StreamSocket();
var serverHost = new Windows.Networking.HostName(ip);
await socket.ConnectAsync(serverHost, port);
//Send request
DataWriter writer = new DataWriter(socket.OutputStream);
writer.WriteUInt32(writer.MeasureString(strReq));
writer.WriteString(strReq);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
writer.Dispose();
//Read response
Stream streamIn = socket.InputStream.AsStreamForRead();
int bsize = 4096;
byte[] buffer = new byte[bsize];
int readByte = await streamIn.ReadAsync(
buffer,
0,
bsize
);
if (readByte <= 0)
{
//return null if there is no response
return(doc);
}
byte[] rdata = new byte[readByte];
Array.Copy(buffer, rdata, readByte);
streamIn.Dispose();
socket.Dispose();
doc = XDocument.Parse(Encoding.ASCII.GetString(rdata));
}
catch (Exception ex)
{
}
return(doc);
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
if (this.btnConnect.Label == "Connect")
{
try
{
Windows.Networking.HostName serverHost = new Windows.Networking.HostName(txtIP.Text);
string serverPort = txtPort.Text;
await socket.ConnectAsync(serverHost, serverPort);
Stream streamOut = socket.OutputStream.AsStreamForWrite();
BinaryWriter writer = new BinaryWriter(streamOut);
Stream streamIn = socket.InputStream.AsStreamForRead();
BinaryReader reader = new BinaryReader(streamIn);
Boolean connOn = true;
int countLimit = handshake.Length + zonelabels.Length;
handshake[0] = App.createLoginString(this.txtPassword.Password);
int[] fixedLenght = new int[] { 53 };
this.txtEvent.Text = "Connecting...";
this.txtStatus.Text = "Status: Connecting...";
await comms(reader, writer, handshake, answerLenghtArray, 0);
this.txtEvent.Text = "Retrieving Zone Labels...";
this.txtStatus.Text = "Status: Connected";
this.btnConnect.Label = "Disconnect";
await comms(reader, writer, zonelabels, fixedLenght, 2);
int i = 1;
foreach (CheckBox item in this.gridView.Items)
{
item.Content = Mappings.zoneLabel[i];
i++;
}
while (connOn)
{
await comms(reader, writer, retrieveInfo, fixedLenght, 1000);
}
}
catch (Exception er)
{
Debug.WriteLine("ops...");
Debug.WriteLine(er.Message);
}
}
else
{
socket.Dispose();
}
}
private async Task OnSend()
{
if (string.IsNullOrEmpty(IPAddress))
{
await NotifyAsync("Destination IP is Empty");
return;
}
IsBusy = true;
var contentType = Enum.Parse <ContentType>(_selectedContentType.ToString());
if (CoreApplication.Properties.ContainsKey("listener"))
{
Windows.Networking.Sockets.StreamSocket socket = null;
try
{
var host = new Windows.Networking.HostName(IPAddress);
socket = new Windows.Networking.Sockets.StreamSocket();
socket.Control.KeepAlive = false;
await socket.ConnectAsync(host, App.ServiceName);
switch (contentType)
{
case ContentType.File:
await SendFileAsync(socket.InputStream, socket.OutputStream);
break;
case ContentType.Code:
var language = Enum.Parse <HighlightedLanguage>(_language.ToString());
await SendContentAsync(socket.InputStream, socket.OutputStream, contentType, language);
break;
case ContentType.Text:
await SendContentAsync(socket.InputStream, socket.OutputStream, contentType);
break;
}
}
catch (Exception ex)
{
await NotifyAsync(ex.Message);
}
finally
{
socket?.Dispose();
IsBusy = false;
}
}
else
{
await NotifyAsync("Somthing wrong.. Please Restart the app and try again");
}
}
// Purpose: Connect to node.js application (lamechat.js)
// End Result: node.js app now has a socket open that can send
// messages back to this tcp client application
private async void cmdConnect_Click(object sender, RoutedEventArgs e)
{
AddPrompt();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName("127.0.0.1");
await tcpClient.ConnectAsync(serverHost, "8000");
serverStream = tcpClient.OutputStream.AsStreamForWrite();
StreamWriter writer = new StreamWriter(serverStream);
string request = txtChatName.Text.Trim() + " is joining";
await writer.WriteLineAsync(request);
await writer.FlushAsync();
Stream streamIn = tcpClient.InputStream.AsStreamForRead();
StreamReader reader = new StreamReader(streamIn);
string response = await reader.ReadLineAsync();
//byte[] outStream = Encoding.ASCII.GetBytes(txtChatName.Text.Trim()
// + " is joining");
//serverStream.Write(outStream, 0, outStream.Length);
//serverStream.Flush();
// upload as javascript blob
//Task taskOpenEndpoint = Task.Factory.StartNew(() =>
//{
// while (true)
// {
// // Read bytes
// serverStream = tcpClient.InputStream.AsStreamForRead();
// byte[] message = new byte[4096];
// int bytesRead;
// bytesRead = 0;
// try
// {
// // Read up to 4096 bytes
// bytesRead = serverStream.Read(message, 0, 4096);
// }
// catch
// {
// /*a socket error has occured*/
// }
// //We have rad the message.
// ASCIIEncoding encoder = new ASCIIEncoding();
// // Update main window
// AddMessage(encoder.GetString(message, 0, bytesRead));
// //Thread.Sleep(500);
// }
//});
}
/// <summary>
/// This is the click handler for the 'ConnectSocket' button.
/// </summary>
/// <param name="sender">Object for which the event was generated.</param>
/// <param name="e">Event's parameters.</param>
private async void ConnectSocket_Click(object sender, RoutedEventArgs e)
{
// By default 'HostNameForConnect' is disabled and host name validation is not required. When enabling the
// text box validating the host name is required since it was received from an untrusted source
// (user input). The host name is validated by catching ArgumentExceptions thrown by the HostName
// constructor for invalid input.
Windows.Networking.HostName hostName;
try
{
hostName = new Windows.Networking.HostName(HostNameForConnect.Text);
}
catch (ArgumentException)
{
return;
}
string[] serviceNames =
{
_vlcLeftLeftServiceName.Text,
_vlcLeftFrontServiceName.Text,
_vlcRightFrontServiceName.Text,
_vlcRightRightServiceName.Text,
};
// Save the socket, so subsequent steps can use it.
try
{
foreach (var serviceName in serviceNames)
{
Task.Run(async() =>
{
var socket = new Windows.Networking.Sockets.StreamSocket();
socket.Control.KeepAlive = true;
await socket.ConnectAsync(hostName, serviceName);
OnServerConnectionEstablished(socket);
});
}
}
catch (Exception exception)
{
// If this is an unknown status it means that the error is fatal and retry will likely fail.
if (Windows.Networking.Sockets.SocketError.GetStatus(exception.HResult) ==
Windows.Networking.Sockets.SocketErrorStatus.Unknown)
{
throw;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public async Task SendContinuiously(string message)
{
// this will temperarly hold the responce string
string responce; // may be
// set the is listening value to true while this is going on
IsListening = true;
try
{
// this will keep running this fuction until another thead stops it
while (IsListening)
{
// Create the StreamSocket and establish a connection to the echo server.
streamSocket = new Windows.Networking.Sockets.StreamSocket();
// The server hostname that we will be establishing a connection to. In this example, the server and client are in the same process.
await streamSocket.ConnectAsync(hostName, this.portNumber);
// send the message
using (Stream outputStream = streamSocket.OutputStream.AsStreamForWrite())
{
//
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(message);
await streamWriter.FlushAsync();
}
}
// wait for the message
using (Stream inputStream = streamSocket.InputStream.AsStreamForRead())
{
using (StreamReader streamReader = new StreamReader(inputStream))
{
responce = await streamReader.ReadLineAsync();
}
}
message = this.responder.Respond(ref responce);
}
}
catch (Exception ex)
{
Windows.Networking.Sockets.SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
this.Output(MessageHelper.MessageType.Exception, webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
}
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
var streamSocketListener = new Windows.Networking.Sockets.StreamSocketListener();
streamSocketListener.ConnectionReceived += this.StreamSocketListener_ConnectionReceived;
await streamSocketListener.BindServiceNameAsync("1337");
var streamSocket = new Windows.Networking.Sockets.StreamSocket();
await streamSocket.ConnectAsync(new Windows.Networking.HostName("localhost"), "1337");
this.SendMultipleBuffersInefficiently(streamSocket, "Hello, World!");
//this.BatchedSendsCSharpOnly(streamSocket, "Hello, World!");
//this.BatchedSendsAnyUWPLanguage(streamSocket, "Hello, World!");
}
private Task <Stream> OpenStreamAsyncImpl()
{
return(Task.Run <Stream>(async() =>
{
#if WINDOWS_UWP
await CoreWindow.GetForCurrentThread().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
await _service.RequestAccessAsync();
});
#endif
Windows.Networking.Sockets.StreamSocket socket = new Windows.Networking.Sockets.StreamSocket();
await socket.ConnectAsync(_service.ConnectionHostName, _service.ConnectionServiceName);
return new NetworkStream(socket);
}));
}
private async void UpdateList()
{
try
{
// Create the StreamSocket and establish a connection to the echo server.
using (var streamSocket2 = new Windows.Networking.Sockets.StreamSocket())
{
// The server hostname that we will be establishing a connection to. In this example, the server and client are in the same process.
var hostName = new Windows.Networking.HostName(ip.Text);
await streamSocket2.ConnectAsync(hostName, MainPage.outPortNumber);
// Send a request to the server and update list.
string request = "UpdateSaveList";
using (Stream outputStream = streamSocket2.OutputStream.AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(request);
await streamWriter.FlushAsync();
}
}
string response;
using (Stream inputStream = streamSocket2.InputStream.AsStreamForRead())
{
using (StreamReader streamReader = new StreamReader(inputStream))
{
this.SaveList.Items.Clear();
response = await streamReader.ReadLineAsync();
string[] responses = response.Split(',');
foreach (string rep in responses)
{
if (rep != "")
{
this.SaveList.Items.Add(rep);
}
}
}
}
}
}
catch (Exception ex)
{
}
}
private static async void StartClient()
{
try
{
using (var streamSocket = new Windows.Networking.Sockets.StreamSocket())
{
var hostName = new Windows.Networking.HostName("localhost");
Debug.WriteLine("client is trying to connect...");
await streamSocket.ConnectAsync(hostName, PortNumber);
Debug.WriteLine("client connected");
string request = "CLIENT";
using (Stream outputStream = streamSocket.OutputStream.AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(request);
await streamWriter.FlushAsync();
}
}
Debug.WriteLine(string.Format("client sent the request: \"{0}\"", request));
string response;
using (Stream inputStream = streamSocket.InputStream.AsStreamForRead())
{
using (StreamReader streamReader = new StreamReader(inputStream))
{
response = await streamReader.ReadLineAsync();
}
}
Debug.WriteLine(string.Format("client received the response: \"{0}\" ", response));
}
Debug.WriteLine("client closed its socket");
}
catch (Exception ex)
{
Windows.Networking.Sockets.SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
Debug.WriteLine(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
}
}
public override bool ConnectAsync(TimeSpan timeout, TransportAsyncCallbackArgs callbackArgs)
{
var streamSocket = new Windows.Networking.Sockets.StreamSocket();
var addr = this.transportSettings.Host;
this.callbackArgs = callbackArgs;
var connectTask = streamSocket.ConnectAsync(new Windows.Networking.HostName(addr), this.transportSettings.Port.ToString(), Windows.Networking.Sockets.SocketProtectionLevel.PlainSocket).AsTask();
connectTask.ContinueWith(_ =>
{
TransportBase transport = null;
Exception exception = null;
try
{
transport = new TcpTransport(streamSocket, this.transportSettings);
transport.Open();
}
catch (Exception exp)
{
if (Fx.IsFatal(exp))
{
throw;
}
exception = exp;
if (transport != null)
{
transport.SafeClose();
}
transport = null;
}
var completeSynchronously = false;
this.callbackArgs.CompletedSynchronously = completeSynchronously;
this.callbackArgs.Exception = exception;
this.callbackArgs.Transport = transport;
if (!completeSynchronously)
{
this.callbackArgs.CompletedCallback(this.callbackArgs);
}
});
return(true);
}
public override bool ConnectAsync(TimeSpan timeout, TransportAsyncCallbackArgs callbackArgs)
{
var streamSocket = new Windows.Networking.Sockets.StreamSocket();
var addr = this.transportSettings.Host;
this.callbackArgs = callbackArgs;
var connectTask = streamSocket.ConnectAsync(new Windows.Networking.HostName(addr), this.transportSettings.Port.ToString(), Windows.Networking.Sockets.SocketProtectionLevel.PlainSocket).AsTask();
connectTask.ContinueWith(_ =>
{
TransportBase transport = null;
Exception exception = null;
try
{
transport = new TcpTransport(streamSocket, this.transportSettings);
transport.Open();
}
catch (Exception exp)
{
if (Fx.IsFatal(exp))
{
throw;
}
exception = exp;
if (transport != null)
{
transport.SafeClose();
}
transport = null;
}
var completeSynchronously = false;
this.callbackArgs.CompletedSynchronously = completeSynchronously;
this.callbackArgs.Exception = exception;
this.callbackArgs.Transport = transport;
if (!completeSynchronously)
{
this.callbackArgs.CompletedCallback(this.callbackArgs);
}
});
return true;
}
public async Task Start()
{
try
{
//The server hostname that we will be establishing a connection to. We will be running the server and client locally,
//so we will use localhost as the hostname.
Windows.Networking.HostName serverHost = new Windows.Networking.HostName("127.0.0.1");
//Every protocol typically has a standard port number. For example HTTP is typically 80, FTP is 20 and 21, etc.
//For the echo server/client application we will use a random port 8080.
string serverPort = "8080";
await socket.ConnectAsync(serverHost, serverPort);
}
catch (Exception e)
{
//Handle exception here.
}
}
public async Task <bool> ConnectAsync()
{
try
{
sock = new Windows.Networking.Sockets.StreamSocket();
Windows.Networking.HostName hostname = new Windows.Networking.HostName(ServerName);
await sock.ConnectAsync(hostname, ServiceName);
writer = new Windows.Storage.Streams.DataWriter(sock.OutputStream);
reader = new Windows.Storage.Streams.DataReader(sock.InputStream);
StartReceiveDataAsync();
return(true);
}
catch
{
return(false);
}
}
public async void init()
{
try
{
Windows.Networking.Sockets.StreamSocket socket = new Windows.Networking.Sockets.StreamSocket();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName("localhost");
string serverPort = "1337";
await socket.ConnectAsync(serverHost, serverPort);
streamIn = socket.InputStream.AsStreamForRead();
streamOut = socket.OutputStream.AsStreamForWrite();
Debug.WriteLine("Connected successfully");
}
catch (Exception e)
{
Debug.WriteLine("Failed to connect: " + e.Message);
}
}
private async void UpdateDataSave(string name)
{
try
{
// Create the StreamSocket and establish a connection to the echo server.
using (var streamSocket = new Windows.Networking.Sockets.StreamSocket())
{
// The server hostname that we will be establishing a connection to. In this example, the server and client are in the same process.
var hostName = new Windows.Networking.HostName("localhost");
await streamSocket.ConnectAsync(hostName, MainPage.outPortNumber);
// Send a request to the server and update list.
string request = name;
using (Stream outputStream = streamSocket.OutputStream.AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(request);
await streamWriter.FlushAsync();
}
}
string response;
using (Stream inputStream = streamSocket.InputStream.AsStreamForRead())
{
using (StreamReader streamReader = new StreamReader(inputStream))
{
response = await streamReader.ReadLineAsync();
string[] responses = response.Split(',');
this.name.Text = "Task name : " + responses[0];
this.source.Text = "Source folder : " + responses[1];
this.target.Text = "Target folder : " + responses[2];
this.progressBar.Value = Convert.ToDouble(responses[3]);
}
}
}
}
catch (Exception ex)
{
}
}
private async void ReadThread(object host)
{
reading = true;
Windows.Networking.Sockets.StreamSocket socket = new Windows.Networking.Sockets.StreamSocket();
await socket.ConnectAsync((Windows.Networking.HostName) host, InTheHand.Devices.Bluetooth.Rfcomm.RfcommServiceId.SerialPort.AsString());
byte[] buffer = new byte[32];
System.Text.StringBuilder sb = new StringBuilder();
while (reading)
{
IBuffer returnedBuffer = await socket.InputStream.ReadAsync(buffer.AsBuffer(), (uint)buffer.Length, Windows.Storage.Streams.InputStreamOptions.Partial);
// break loop if response is empty (connection fail etc)
if (returnedBuffer.Length == 0)
{
break;
}
string s = System.Text.Encoding.UTF8.GetString(buffer, 0, (int)returnedBuffer.Length);
if (!string.IsNullOrEmpty(s))
{
if (s.IndexOf('\0') > -1)
{
s = s.Substring(0, s.IndexOf('\0'));
}
sb.Append(s);
// Only process when we have a complete line
if (sb.ToString().EndsWith("\r"))
{
Dispatcher.BeginInvoke(new Action <string>(this.InsertMessage), sb.ToString());
sb.Clear();
}
}
}
socket.Dispose();
}
public async Task <bool> ConnectAsync()
{
//Monitor.Enter(nstreamlock);
try
{
sock = new Windows.Networking.Sockets.StreamSocket();
Windows.Networking.HostName hostname = new Windows.Networking.HostName(ServerName);
await sock.ConnectAsync(hostname, ServiceName);
writer = new Windows.Storage.Streams.DataWriter(sock.OutputStream);
reader = new Windows.Storage.Streams.DataReader(sock.InputStream);
//Monitor.Exit(nstreamlock);
return(true);
}
catch
{
Disconnect();
// Monitor.Exit(nstreamlock);
return(false);
}
}
/// <summary>
/// Just sends a single message to another device
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public async Task Send(string message)
{
try
{
// Create the StreamSocket and establish a connection to the echo server.
streamSocket = new Windows.Networking.Sockets.StreamSocket();
// The server hostname that we will be establishing a connection to. In this example, the server and client are in the same process.
await streamSocket.ConnectAsync(hostName, this.portNumber);
// send the message
await SendInternal(message);
this.Close();
}
catch (Exception ex)
{
Windows.Networking.Sockets.SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
this.Output(MessageHelper.MessageType.Exception, webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
}
}
/// <summary>
/// This is the click handler for the 'ConnectSocket' button.
/// </summary>
/// <param name="sender">Object for which the event was generated.</param>
/// <param name="e">Event's parameters.</param>
private async void ConnectSocket_Click(object sender, RoutedEventArgs e)
{
// By default 'HostNameForConnect' is disabled and host name validation is not required. When enabling the
// text box validating the host name is required since it was received from an untrusted source
// (user input). The host name is validated by catching ArgumentExceptions thrown by the HostName
// constructor for invalid input.
Windows.Networking.HostName hostName;
try
{
hostName = new Windows.Networking.HostName(HostNameForConnect.Text);
}
catch (ArgumentException)
{
return;
}
var pvCameraSocket = new Windows.Networking.Sockets.StreamSocket();
pvCameraSocket.Control.KeepAlive = true;
// Save the socket, so subsequent steps can use it.
try
{
// Connect to the server (by default, the listener we created in the previous step).
await pvCameraSocket.ConnectAsync(hostName, _pvServiceName.Text);
}
catch (Exception exception)
{
// If this is an unknown status it means that the error is fatal and retry will likely fail.
if (Windows.Networking.Sockets.SocketError.GetStatus(exception.HResult) ==
Windows.Networking.Sockets.SocketErrorStatus.Unknown)
{
throw;
}
}
OnServerConnectionEstablished(
pvCameraSocket);
}
public async void StartClient()
{
try
{
// Create the StreamSocket and establish a connection to the echo server.
using (var streamSocket = new Windows.Networking.Sockets.StreamSocket())
{
// The server hostname that we will be establishing a connection to. In this example, the server and client are in the same process.
var hostName = new Windows.Networking.HostName("localhost");
await streamSocket.ConnectAsync(hostName, PortNumber);
// Send a request to the echo server.
string request = "Hello, World!";
using (Stream outputStream = streamSocket.OutputStream.AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(request);
await streamWriter.FlushAsync();
}
}
// Read data from the echo server.
string response;
using (Stream inputStream = streamSocket.InputStream.AsStreamForRead())
{
using (StreamReader streamReader = new StreamReader(inputStream))
{
response = await streamReader.ReadLineAsync();
}
}
}
}
catch (Exception ex)
{
Windows.Networking.Sockets.SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
}
}
//Create a socket and attempt connection to remote server
//In future, an entry from a 2D UWP application can provide inputs into the hard coded values
#if UNITY_UWP
async void ConnectToRemote()
{
try
{
//if (dataExchange != null)
// StopExchange();
//Socket setup
socket = new Windows.Networking.Sockets.StreamSocket();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName("40.76.194.87");
await socket.ConnectAsync(serverHost, "62520");
Debug.LogError("connection successful");
Stream outStream = socket.OutputStream.AsStreamForWrite();
writer = new StreamWriter(outStream);
Stream inStream = socket.InputStream.AsStreamForRead();
reader = new StreamReader(inStream);
}
catch (System.Exception except)
{
Debug.LogError(except.ToString());
}
}
private async Task ConnectUWP(string host, string port)
{
Debug.Log("ConnectUWP");
if (exchangeTask != null)
{
StopExchange();
}
socket = new Windows.Networking.Sockets.StreamSocket();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName(host);
try {
await socket.ConnectAsync(serverHost, port);
byteWriter = socket.OutputStream.AsStreamForWrite();
writer = new StreamWriter(byteWriter)
{
AutoFlush = true
};
} catch (Exception e) {
errorStatus = e.ToString();
Debug.Log("connection error:" + errorStatus);
}
}
private async void LocalIpAsync()
{
try
{
var settings = ApplicationData.Current.LocalSettings;
object value = settings.Values["IP"];
string IPValue = value.ToString();
IP.Text = IPValue;
mTimer2.Start();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName(IPValue);
string serverPort = "1337";
socket = new Windows.Networking.Sockets.StreamSocket();
await socket.ConnectAsync(serverHost, serverPort);
Stream streamOut = socket.OutputStream.AsStreamForWrite();
Writer = new StreamWriter(streamOut);
//create timer
mTimer.Tick += MTimer_Tick;
mTimer.Interval = TimeSpan.FromSeconds(5);
mTimer.Start();
//read data from server
Stream streamIn = socket.InputStream.AsStreamForRead();
StreamReader reader = new StreamReader(streamIn);
if (reader != null)
{
connectFalse.Visibility = Visibility.Visible;
connectFalse.Content = reader;
}
}
catch (Exception e)
{
connectbutton.Visibility = Visibility.Visible;
stackPanel.Visibility = Visibility.Visible;
serverIP.Visibility = Visibility.Visible;
VerticalPage verticalpage = frame.Content as VerticalPage;
verticalpage.hideImg();
}
}
/// <summary>
/// Creates a TCP connection and writes the report to the socket at the provided hostname and port
/// </summary>
/// <param name="hostName">hostname</param>
/// <param name="port">port</param>
/// <returns>TrxResultChannel</returns>
public static Task <TrxResultChannel> CreateTcpTrxResultChannel(string hostName, int port)
{
if ((port < 0) || (port > ushort.MaxValue))
{
throw new ArgumentException("port");
}
var HostName = hostName ?? throw new ArgumentNullException(nameof(hostName));
var Port = port;
#if __IOS__ || MAC
UIKit.UIApplication.SharedApplication.NetworkActivityIndicatorVisible = true;
#endif
try
{
#if __IOS__ || MAC || __ANDROID__
var client = new System.Net.Sockets.TcpClient(hostName, port);
var channel = new TrxResultChannel(client.GetStream(), true);
#if __IOS__ || MAC
channel.showNetworkIndicator = true;
#endif
return(Task.FromResult(channel));
#elif WINDOWS_PHONE || NETFX_CORE
var socket = new Windows.Networking.Sockets.StreamSocket();
return(socket.ConnectAsync(new Windows.Networking.HostName(hostName), port.ToString(CultureInfo.InvariantCulture))
.AsTask()
.ContinueWith(_ => new TrxResultChannel(socket.OutputStream.AsStreamForWrite(), true)));
#endif
}
catch
{
#if __IOS__ || MAC
UIKit.UIApplication.SharedApplication.NetworkActivityIndicatorVisible = false;
#endif
throw;
}
}
public void Connect()
{
TvDirectSocket = new Windows.Networking.Sockets.StreamSocket();
TvDirectSocket.ConnectAsync(ConnectedHostName, ConnectedPort.ToString()).Completed += newConnected;
ConnectionState = TvConnectionState.Connecting;
if (Connecting != null)
{
Connecting();
}
}
private async Task StartClientBD(string zapros, string ip)
{
try
{
// Create the StreamSocket and establish a connection to the echo server.
using (var streamSocket = new Windows.Networking.Sockets.StreamSocket())
{
// The server hostname that we will be establishing a connection to. In this example, the server and client are in the same process.
var hostName = new Windows.Networking.HostName(ip);
// this.clientListBox.Items.Add("client is trying to connect...");
// MessageDialog messageDialog1 = new MessageDialog("client is trying to connect...");
// await messageDialog1.ShowAsync();
await streamSocket.ConnectAsync(hostName, "8888");
// this.clientListBox.Items.Add("client connected");
// messageDialog1 = new MessageDialog("client connected");
// await messageDialog1.ShowAsync();
// Send a request to the echo server.
string request = "BDB!" + "\t" + zapros;
using (Stream outputStream = streamSocket.OutputStream.AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(request);
await streamWriter.FlushAsync();
}
}
// this.clientListBox.Items.Add(string.Format("client sent the request: \"{0}\"", request));
// messageDialog1 = new MessageDialog("client sent the request: \"{0}\"", request);
// await messageDialog1.ShowAsync();
// Read data from the echo server.
string response = null;
List <byte> list = new List <byte>();
byte[] Buffer1 = new byte[1024];
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile =
await storageFolder.CreateFileAsync("sample.xml",
Windows.Storage.CreationCollisionOption.ReplaceExisting);
using (Stream inputStream = streamSocket.InputStream.AsStreamForRead())
{
int Count;
while ((Count = inputStream.Read(Buffer1, 0, Buffer1.Length)) > 0)
{
// Преобразуем эти данные в строку и добавим ее к переменной Request
for (int i = 0; i < Count; i++)
{
list.Add(Buffer1[i]);
}
// Запрос должен обрываться последовательностью \r\n\r\n
// Либо обрываем прием данных сами, если длина строки Request превышает 4 килобайта
// Нам не нужно получать данные из POST-запроса (и т. п.), а обычный запрос
// по идее не должен быть больше 4 килобайт
}
if (list.Count != 0)
{
MessageDialog messageDialog12 = new MessageDialog(list.Count.ToString());
await messageDialog12.ShowAsync();
// IBuffer buffer = Buffer1.AsBuffer();
await Windows.Storage.FileIO.WriteBytesAsync(sampleFile, list.ToArray());
MessageDialog messageDialog112 = new MessageDialog("файл создан");
await messageDialog112.ShowAsync();
}
}
if (list.Count != 0)
{
DataSet ds = new DataSet();
// XDocument d= System.Xml.Linq.XDocument.Load(sampleFile.Path);
ds.ReadXml(sampleFile.Path);
// выбираем первую таблицу
DataTable dt = ds.Tables[0];
await ParserTabSobData(dt);
// ViewModel.SostoYs = vs[0];
// if (vs.Length > 1)
// {
// }
}
else
{
MessageDialog messageDialog12 = new MessageDialog("Данные по запросу не обнаружены");
await messageDialog12.ShowAsync();
}
MessageDialog messageDialog122 = new MessageDialog("Конец");
await messageDialog122.ShowAsync();
}
// this.clientListBox.Items.Add("client closed its socket");
// MessageDialog messageDialog = new MessageDialog("client closed its socket");
// await messageDialog.ShowAsync();
}
catch (Exception ex)
{
MessageDialog messageDialog = new MessageDialog("Error" + ex.ToString());
messageDialog.ShowAsync();
}
}
