private async void InitializeSocket()
{
try
{
StreamWebSocket webSocket = streamWebSocket;
if (webSocket == null)
{
Uri server;
if(!Uri.TryCreate("ws://192.168.0.2", UriKind.Absolute, out server)) // działa tylko u mnie albo jak bedziesz podłączony do serwera
{
return;
}
webSocket = new StreamWebSocket();
webSocket.Closed += Closed;
await webSocket.ConnectAsync(server);
streamWebSocket = webSocket;
readBuffer = new byte[6000000];
Task recieving = Task.Factory.StartNew(ReceiveData, webSocket.InputStream.AsStreamForRead(), TaskCreationOptions.LongRunning);
Task sending = Task.Factory.StartNew(SendData, webSocket.OutputStream, TaskCreationOptions.LongRunning);
}
}
catch(Exception ex)
{
WebErrorStatus status = WebSocketError.GetStatus(ex.GetBaseException().HResult);
}
}
public async Task ConnectAsync(Address address)
{
StreamWebSocket sws = new StreamWebSocket();
sws.Control.SupportedProtocols.Add(WebSocketSubProtocol);
sws.Closed += this.OnWebSocketClosed;
Uri uri = new UriBuilder()
{
Scheme = address.Scheme,
Port = GetDefaultPort(address.Scheme, address.Port),
Host = address.Host,
Path = address.Path
}.Uri;
await sws.ConnectAsync(uri);
this.webSocket = sws;
}
public static async Task Connect(string uri)
{
StreamWebSocket webSocket = null;
try
{
webSocket = new StreamWebSocket();
await webSocket.ConnectAsync(new Uri(uri));
await Task.WhenAll(Receive(webSocket), Send(webSocket));
}
catch (Exception ex)
{
Console.WriteLine("Exception: {0}", ex);
}
finally
{
if (webSocket != null)
webSocket.Close(1000, string.Empty);
Console.WriteLine();
Console.WriteLine("WebSocket closed.");
}
}
private async void Start_Click(object sender, RoutedEventArgs e)
{
// Have we connected yet?
if (streamWebSocket != null)
{
rootPage.NotifyUser("Already connected", NotifyType.StatusMessage);
return;
}
// Validating the URI is required since it was received from an untrusted source (user input).
// The URI is validated by calling TryGetUri() that will return 'false' for strings that are not
// valid WebSocket URIs.
// Note that when enabling the text box users may provide URIs to machines on the intrAnet
// or intErnet. In these cases the app requires the "Home or Work Networking" or
// "Internet (Client)" capability respectively.
Uri server;
if (!rootPage.TryGetUri(ServerAddressField.Text, out server))
{
return;
}
try
{
rootPage.NotifyUser("Connecting to: " + server, NotifyType.StatusMessage);
streamWebSocket = new StreamWebSocket();
// Dispatch close event on UI thread. This allows us to avoid synchronizing access to streamWebSocket.
streamWebSocket.Closed += async (senderSocket, args) =>
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => Closed(senderSocket, args));
};
await streamWebSocket.ConnectAsync(server);
readBuffer = new byte[1000];
// Start a background task to continuously read for incoming data
Task receiving = Task.Factory.StartNew(Scenario2ReceiveData,
streamWebSocket.InputStream.AsStreamForRead(), TaskCreationOptions.LongRunning);
// Start a background task to continuously write outgoing data
Task sending = Task.Factory.StartNew(Scenario2SendData,
streamWebSocket.OutputStream, TaskCreationOptions.LongRunning);
rootPage.NotifyUser("Connected", NotifyType.StatusMessage);
}
catch (Exception ex) // For debugging
{
if (streamWebSocket != null)
{
streamWebSocket.Dispose();
streamWebSocket = null;
}
WebErrorStatus status = WebSocketError.GetStatus(ex.GetBaseException().HResult);
switch (status)
{
case WebErrorStatus.CannotConnect:
case WebErrorStatus.NotFound:
case WebErrorStatus.RequestTimeout:
rootPage.NotifyUser("Cannot connect to the server. Please make sure " +
"to run the server setup script before running the sample.", NotifyType.ErrorMessage);
break;
case WebErrorStatus.Unknown:
throw;
default:
rootPage.NotifyUser("Error: " + status, NotifyType.ErrorMessage);
break;
}
OutputField.Text += ex.Message + "\r\n";
}
}
async Task<bool> RegisterWithCCTHelper(string serverUri)
{
bool result = false;
socket = new StreamWebSocket();
// Specify the keepalive interval expected by the server for this app
// in order of minutes.
const int serverKeepAliveInterval = 30;
// Specify the channelId string to differentiate this
// channel instance from any other channel instance.
// When background task fires, the channel object is provided
// as context and the channel id can be used to adapt the behavior
// of the app as required.
const string channelId = "channelOne";
// IMPORTANT: Note that this is a websocket sample, therefore the
// keepalive task class is provided by Windows for websockets.
// For websockets, the system does the keepalive on behalf of the
// app but the app still needs to specify this well known keepalive task.
// This should be done here in the background registration as well
// as in the package manifest.
const string WebSocketKeepAliveTask = "Windows.Networking.Sockets.WebSocketKeepAlive";
// Try creating the controlchanneltrigger if this has not been already
// created and stored in the property bag.
Diag.DebugPrint("RegisterWithCCTHelper Starting...");
ControlChannelTriggerStatus status;
Diag.DebugPrint("Create ControlChannelTrigger ...");
// Create the ControlChannelTrigger object and request a hardware slot for this app.
// If the app is not on LockScreen, then the ControlChannelTrigger constructor will
// fail right away.
try
{
channel = new ControlChannelTrigger(channelId, serverKeepAliveInterval,
ControlChannelTriggerResourceType.RequestHardwareSlot);
}
catch (UnauthorizedAccessException exp)
{
Diag.DebugPrint("Please add the app to the lock screen." + exp.Message);
return result;
}
Uri serverUriInstance;
try
{
serverUriInstance = new Uri(serverUri);
}
catch (Exception exp)
{
Diag.DebugPrint("Error creating URI: " + exp.Message);
return result;
}
// Register the apps background task with the trigger for keepalive.
var keepAliveBuilder = new BackgroundTaskBuilder();
keepAliveBuilder.Name = "KeepaliveTaskForChannelOne";
keepAliveBuilder.TaskEntryPoint = WebSocketKeepAliveTask;
keepAliveBuilder.SetTrigger(channel.KeepAliveTrigger);
keepAliveBuilder.Register();
// Register the apps background task with the trigger for push notification task.
var pushNotifyBuilder = new BackgroundTaskBuilder();
pushNotifyBuilder.Name = "PushNotificationTaskForChannelOne";
pushNotifyBuilder.TaskEntryPoint = "BackgroundTaskHelper.PushNotifyTask";
pushNotifyBuilder.SetTrigger(channel.PushNotificationTrigger);
pushNotifyBuilder.Register();
// Tie the transport method to the ControlChannelTrigger object to push enable it.
// Note that if the transport's TCP connection is broken at a later point of time,
// the ControlChannelTrigger object can be reused to plug in a new transport by
// calling UsingTransport API again.
Diag.DebugPrint("Calling UsingTransport() ...");
try
{
channel.UsingTransport(socket);
// Connect the socket
//
// If connect fails or times out it will throw exception.
await socket.ConnectAsync(serverUriInstance);
Diag.DebugPrint("Connected");
// Call WaitForPushEnabled API to make sure the TCP connection has
// been established, which will mean that the OS will have allocated
// any hardware slot for this TCP connection.
//
// In this sample, the ControlChannelTrigger object was created by
// explicitly requesting a hardware slot.
//
// On Non-AOAC systems, if app requests hardware slot as above,
// the system will fallback to a software slot automatically.
//
// On AOAC systems, if no hardware slot is available, then app
// can request a software slot [by re-creating the ControlChannelTrigger object].
status = channel.WaitForPushEnabled();
Diag.DebugPrint("WaitForPushEnabled() completed with status: " + status);
if (status != ControlChannelTriggerStatus.HardwareSlotAllocated
&& status != ControlChannelTriggerStatus.SoftwareSlotAllocated)
{
throw new Exception(string.Format("Neither hardware nor software slot could be allocated. ChannelStatus is {0}", status.ToString()));
}
// Store the objects created in the property bag for later use.
// NOTE: make sure these objects are free threaded. STA/Both objects can
// cause deadlocks when foreground threads are suspended.
CoreApplication.Properties.Remove(channel.ControlChannelTriggerId);
var appContext = new AppContext(this, socket, channel, channel.ControlChannelTriggerId);
((IDictionary<string, object>)CoreApplication.Properties).Add(channel.ControlChannelTriggerId, appContext);
result = true;
Diag.DebugPrint("RegisterWithCCTHelper Completed.");
// Almost done. Post a read since we are using streamwebsocket
// to allow push notifications to be received.
PostSocketRead(MAX_BUFFER_LENGTH);
}
catch (Exception exp)
{
Diag.DebugPrint("RegisterWithCCTHelper Task failed with: " + exp.Message);
// Exceptions may be thrown for example if the application has not
// registered the background task class id for using real time communications
// broker in the package appx manifest.
}
return result;
}
private async Task StartAsync()
{
// Validating the URI is required since it was received from an untrusted source (user input).
// The URI is validated by calling TryGetUri() that will return 'false' for strings that are not
// valid WebSocket URIs.
// Note that when enabling the text box users may provide URIs to machines on the intrAnet
// or intErnet. In these cases the app requires the "Home or Work Networking" or
// "Internet (Client)" capability respectively.
Uri server = rootPage.TryGetUri(ServerAddressField.Text);
if (server == null)
{
return;
}
streamWebSocket = new StreamWebSocket();
streamWebSocket.Closed += OnClosed;
// If we are connecting to wss:// endpoint, by default, the OS performs validation of
// the server certificate based on well-known trusted CAs. We can perform additional custom
// validation if needed.
if (SecureWebSocketCheckBox.IsChecked == true)
{
// WARNING: Only test applications should ignore SSL errors.
// In real applications, ignoring server certificate errors can lead to Man-In-The-Middle
// attacks. (Although the connection is secure, the server is not authenticated.)
// Note that not all certificate validation errors can be ignored.
// In this case, we are ignoring these errors since the certificate assigned to the localhost
// URI is self-signed and has subject name = fabrikam.com
streamWebSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted);
streamWebSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.InvalidName);
// Add event handler to listen to the ServerCustomValidationRequested event. This enables performing
// custom validation of the server certificate. The event handler must implement the desired
// custom certificate validation logic.
streamWebSocket.ServerCustomValidationRequested += OnServerCustomValidationRequested;
// Certificate validation is meaningful only for secure connections.
if (server.Scheme != "wss")
{
AppendOutputLine("Note: Certificate validation is performed only for the wss: scheme.");
}
}
AppendOutputLine($"Connecting to {server}...");
try
{
await streamWebSocket.ConnectAsync(server);
}
catch (Exception ex) // For debugging
{
streamWebSocket.Dispose();
streamWebSocket = null;
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
return;
}
rootPage.NotifyUser("Connected", NotifyType.StatusMessage);
// Start a task to continuously read for incoming data
Task receiving = ReceiveDataAsync(streamWebSocket);
// Start a task to continuously write outgoing data
Task sending = SendDataAsync(streamWebSocket);
}
