/// <summary>
/// Binds the <code>TcpSocketListener</code> to the specified port on all endpoints and listens for TCP connections.
/// </summary>
/// <param name="port">The port to listen on. If '0', selection is delegated to the operating system.</param>
/// <param name="listenOn">The <code>CommsInterface</code> to listen on. If unspecified, all interfaces will be bound.</param>
/// <returns></returns>
public Task StartListeningAsync(int port, ICommsInterface listenOn = null)
{
if (listenOn != null && !listenOn.IsUsable)
throw new InvalidOperationException("Cannot listen on an unusable interface. Check the IsUsable property before attemping to bind.");
_listenCanceller = new CancellationTokenSource();
_backingStreamSocketListener = new StreamSocketListener();
_backingStreamSocketListener.ConnectionReceived += (sender, args) =>
{
var nativeSocket = args.Socket;
var wrappedSocket = new TcpSocketClient(nativeSocket, _bufferSize);
var eventArgs = new TcpSocketListenerConnectEventArgs(wrappedSocket);
if (ConnectionReceived != null)
ConnectionReceived(this, eventArgs);
};
var sn = port == 0 ? "" : port.ToString();
#if !WP80
if (listenOn != null)
{
var adapter = ((CommsInterface)listenOn).NativeNetworkAdapter;
return _backingStreamSocketListener
.BindServiceNameAsync(sn, SocketProtectionLevel.PlainSocket, adapter)
.AsTask();
}
else
#endif
return _backingStreamSocketListener
.BindServiceNameAsync(sn)
.AsTask();
}
public async void Star()
{
try
{
//Fecha a conexão com a porta que está escutando atualmente
if (listener != null)
{
await listener.CancelIOAsync();
listener.Dispose();
listener = null;
}
//Criar uma nova instancia do listerner
listener = new StreamSocketListener();
//Adiciona o evento de conexão recebida ao método Listener_ConnectionReceived
listener.ConnectionReceived += Listener_ConnectionReceived;
//Espera fazer o bind da porta
await listener.BindServiceNameAsync(Port.ToString());
}
catch (Exception e)
{
//Caso aconteça um erro, dispara o evento de erro
if (OnError != null)
OnError(e.Message);
}
}
/// <summary>
/// Server listens to specified port and accepts connection from client
/// </summary>
public async void StartListen()
{
var ip = (networkInterface != null)
? GetInterfaceIpAddress()
: IPAddress.Any;
tcpServer = new StreamSocketListener();
await tcpServer.BindServiceNameAsync(portNumber.ToString());
tcpServer.ConnectionReceived += TcpServer_ConnectionReceived;
isRunning = true;
// Keep accepting client connection
while (isRunning)
{
if (!tcpServer.Pending())
{
Thread.Sleep(500);
continue;
}
// New client is connected, call event to handle it
var clientThread = new Thread(NewClient);
var tcpClient = tcpServer.AcceptTcpClient();
tcpClient.ReceiveTimeout = 20000;
clientThread.Start(tcpClient.Client);
}
}
/// <summary>
/// 服务器监听
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void listenButton_Click(object sender, RoutedEventArgs e)
{
if (listener != null)
{
await new MessageDialog("监听已经启动了").ShowAsync();
return;
}
listener= new StreamSocketListener();
//监听后连接的事件OnConnection
listener.ConnectionReceived += OnConnection;
//开始监听操作
try
{
await listener.BindServiceNameAsync("22112");
await new MessageDialog("正在监听").ShowAsync();
}
catch (Exception ex)
{
listener = null;
//未知异常
if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown)
{
throw;
}
}
}
private async void StartServer_Click_1(object sender, RoutedEventArgs e)
{
try
{
if (listener == null)
{
// We call it 'local', becuase if this connection doesn't succeed, we do not want
// to loose the possible previous conneted listener.
listener = new StreamSocketListener();
// ConnectionReceived handler must be set before BindServiceNameAsync is called, if not
// "A method was called at an unexpected time. (Exception from HRESULT: 0x8000000E)"
// error occurs.
listener.ConnectionReceived += OnConnectionReceived;
// Trying to bind more than once to the same port throws "Only one usage of each socket
// address (protocol/network address/port) is normally permitted. (Exception from
// HRESULT: 0x80072740)" exception.
await listener.BindServiceNameAsync("80");
DisplayOutput(TcpServerOutput, "Listening.");
}
}
catch (Exception ex)
{
DisplayOutput(TcpServerOutput, ex.ToString());
}
}
// Use this for initialization
#if !WINDOWS_UWP
void Start()
{
#endif
#if WINDOWS_UWP
async void Start()
{
try
{
socketListener = new Windows.Networking.Sockets.StreamSocketListener();
socketListener.ConnectionReceived += SocketListener_ConnectionReceived;
await socketListener.BindServiceNameAsync("1337");
}
catch (Exception e)
{
counttext.text = "Error: " + e.ToString();
}
#endif
}
// Update is called once per frame
void Update () {
missiontext.text = "Prepare to shoot! 20 of 30";
counttext.text = "Count down: 2";
errortext.text = "Connected!";
progressbar.value = ToSingle(0.66);
if (!request.Equals("Request not received yet"))
{
errortext.text = request;
}
}
public async void Start()
{
this.listener = new StreamSocketListener();
this.listener.ConnectionReceived += Listener_ConnectionReceived;
await listener.BindServiceNameAsync(this.port.ToString());
}
/// <summary>
/// 受付開始
/// </summary>
public async void Start()
{
listener = new StreamSocketListener();
listener.ConnectionReceived += Listener_ConnectionReceived;
// await listener.BindEndpointAsync(LOCALHOST, PORT.ToString());
await listener.BindServiceNameAsync(PORT.ToString());
}
/// <summary>
/// Initialize a server socket listening for incoming Bluetooth Rfcomm connections
/// </summary>
async void InitializeRfcommServer()
{
try
{
ListenButton.IsEnabled = false;
DisconnectButton.IsEnabled = true;
rfcommProvider = await RfcommServiceProvider.CreateAsync(
RfcommServiceId.FromUuid(RfcommChatServiceUuid));
// Create a listener for this service and start listening
socketListener = new StreamSocketListener();
socketListener.ConnectionReceived += OnConnectionReceived;
await socketListener.BindServiceNameAsync(rfcommProvider.ServiceId.AsString(),
SocketProtectionLevel.BluetoothEncryptionAllowNullAuthentication);
// Set the SDP attributes and start Bluetooth advertising
InitializeServiceSdpAttributes(rfcommProvider);
rfcommProvider.StartAdvertising(socketListener);
NotifyStatus("Listening for incoming connections");
}
catch (Exception e)
{
NotifyError(e);
}
}
public async void Start() {
if (isServerActive) return;
isServerActive = true;
listener = new StreamSocketListener();
listener.Control.QualityOfService = SocketQualityOfService.Normal;
listener.ConnectionReceived += ListenerConnectionReceived;
await listener.BindServiceNameAsync(listeningPort.ToString());
WriteIpAddress();
}
private async Task<StreamSocketListener> StartTcpServiceAsync()
{
var tcpService = new StreamSocketListener();
tcpService.ConnectionReceived += TcpService_ConnectionReceived;
await tcpService.BindServiceNameAsync("50000");
return tcpService;
}
/// <include file='../../../_Doc/System.xml' path='doc/members/member[@name="M:System.Net.Sockets.TcpListener.Start"]/*' />
public void Start()
{
_client = null;
_listener = new StreamSocketListener();
_listener.ConnectionReceived += OnConnectionReceived;
// Binding to specific endpoint is currently not supported.
_event.Reset();
Task.Run(async () => await _listener.BindServiceNameAsync(_port));
}
public virtual async Task StartServer()
{
try
{
_listener = CreateStreamSocketListener();
await _listener.BindServiceNameAsync(Port.ToString());
}
catch (Exception ex)
{
throw;
}
}
private async void StartListing_Click(object sender, RoutedEventArgs e)
{
// Listener für Annahme von TCP-Verbindungsanfragen erzeugen
_listener = new StreamSocketListener();
// Eventhandler registrieren, um Verbindungsanfragen zu bearbeiten
_listener.ConnectionReceived += Listener_ConnectionReceived;
// Lauschen und warten auf Verbindungen starten
Status.Text = "Starte Listener...";
await _listener.BindServiceNameAsync(Port);
Status.Text = "Listener bereit.";
}
private async System.Threading.Tasks.Task CreateServerAsync()
{
try
{
socketListener = new Windows.Networking.Sockets.StreamSocketListener();
socketListener.ConnectionReceived += SocketListener_ConnectionReceived;
await socketListener.BindServiceNameAsync("1337");
}
catch (Exception e)
{
Log.Error("Create Server On Port 1337 Error", e);
}
}
public static async void StartListener()
{
try
{
listener = new StreamSocketListener();
listener.ConnectionReceived += OnConnection;
await listener.BindServiceNameAsync(hostPort);
Debug.WriteLine("Listening on {0}", hostPort);
}
catch (Exception e)
{
Debug.WriteLine("StartListener() - Unable to bind listener. " + e.Message);
}
}
/// <summary>
/// Server listens to specified port and accepts connection from client
/// </summary>
public async void StartListen()
{
// var ip = (networkInterface != null)
// ? GetInterfaceIpAddress()
// : IPAddress.Any;
tcpServer = new StreamSocketListener();
tcpServer.ConnectionReceived += TcpServer_ConnectionReceived;
await tcpServer.BindServiceNameAsync(portNumber.ToString(),SocketProtectionLevel.PlainSocket);
isRunning = true;
}
private async Task<StreamSocketListener> startListener()
{
// Create the listening socket
StreamSocketListener listener = new StreamSocketListener();
// This is the event that gets triggered when somebody connects to us
listener.ConnectionReceived += listener_ConnectionReceived;
// We'll bind to the port given in portTextbox
await listener.BindServiceNameAsync(this.portTextbox.Text);
// Return our socket
return listener;
}
public async void InitializeReceiver()
{
// Initialize the provider for the hosted RFCOMM service // RfcommServiceId FromUuid(Guid uuid);
_provider = await RfcommServiceProvider.CreateAsync(RfcommServiceId.FromUuid(btUuid));
// Create a listener for this service and start listening
_listener = new StreamSocketListener();
_listener.ConnectionReceived += Listener_ConnectionReceived;
await _listener.BindServiceNameAsync(_provider.ServiceId.AsString(), SocketProtectionLevel.BluetoothEncryptionAllowNullAuthentication);
// Set the SDP attributes and start advertising
InitializeServiceSdpAttributes(_provider);
_provider.StartAdvertising(_listener);
}
public async Task StartListener(int Port)
{
try
{
listener = new StreamSocketListener();
listener.ConnectionReceived += OnConnection;
await listener.BindServiceNameAsync(Port.ToString());
Debug.WriteLine(string.Format("Listening on {0}", Port.ToString()));
socketIsConnected = true;
}
catch (Exception e)
{
Debug.WriteLine("StartListener() - Unable to bind listener. " + e.Message);
}
}
public static async void StartListener()
{
try
{
ConnectionStatus = ConnectionStatus.Connecting;
_socketListener = new StreamSocketListener();
_socketListener.ConnectionReceived += OnConnection;
await _socketListener.BindServiceNameAsync(Port);
ConnectionStatus = ConnectionStatus.Listening;
}
catch (Exception e)
{
ConnectionStatus = ConnectionStatus.Failed;
}
}
private async Task Start()
{
if (listener == null)
{
listener = new StreamSocketListener();
listener.ConnectionReceived += Listener_ConnectionReceived;
// If necessary, tweak the listener's control options before carrying out the bind operation.
// These options will be automatically applied to the connected StreamSockets resulting from
// incoming connections (i.e., those passed as arguments to the ConnectionReceived event handler).
// Refer to the StreamSocketListenerControl class' MSDN documentation for the full list of control options.
listener.Control.KeepAlive = false;
await listener.BindServiceNameAsync(ServiceName);
}
}
public async void Start(string host, int port)
{
try
{
listener = new StreamSocketListener();
listener.ConnectionReceived += listener_ConnectionReceived;
await listener.BindServiceNameAsync(port.ToString());
IsWorking = true;
}
catch (Exception e)
{
Log.Message(LogType.ERROR, "{0}", e.Message);
Log.Message();
}
}
private async Task Listener(string portListener)
{
try
{
if (listener == null)
{
listener = new StreamSocketListener();
listener.ConnectionReceived += OnConnectionReceived;
await listener.BindServiceNameAsync(portListener.ToString());
playPage.DisplayMessages(name + " :TCP Listener [local]:" + portListener + " started");
}
}
catch (Exception ex)
{
playPage.DisplayMessages(name + " :ERROR: TCP Listener [local]:" + portListener + " started\n" + ex.ToString());
}
}
/// <summary>
/// Initializes the server using RfcommServiceProvider to advertise the Chat Service UUID and start listening
/// for incoming connections.
/// </summary>
private async void InitializeRfcommServer()
{
ListenButton.IsEnabled = false;
DisconnectButton.IsEnabled = true;
try
{
rfcommProvider = await RfcommServiceProvider.CreateAsync(RfcommServiceId.FromUuid(Constants.RfcommChatServiceUuid));
}
// Catch exception HRESULT_FROM_WIN32(ERROR_DEVICE_NOT_AVAILABLE).
catch (Exception ex) when ((uint)ex.HResult == 0x800710DF)
{
// The Bluetooth radio may be off.
rootPage.NotifyUser("Make sure your Bluetooth Radio is on: " + ex.Message, NotifyType.ErrorMessage);
ListenButton.IsEnabled = true;
DisconnectButton.IsEnabled = false;
return;
}
// Create a listener for this service and start listening
socketListener = new StreamSocketListener();
socketListener.ConnectionReceived += OnConnectionReceived;
var rfcomm = rfcommProvider.ServiceId.AsString();
await socketListener.BindServiceNameAsync(rfcommProvider.ServiceId.AsString(),
SocketProtectionLevel.BluetoothEncryptionAllowNullAuthentication);
// Set the SDP attributes and start Bluetooth advertising
InitializeServiceSdpAttributes(rfcommProvider);
try
{
rfcommProvider.StartAdvertising(socketListener, true);
}
catch (Exception e)
{
// If you aren't able to get a reference to an RfcommServiceProvider, tell the user why. Usually throws an exception if user changed their privacy settings to prevent Sync w/ Devices.
rootPage.NotifyUser(e.Message, NotifyType.ErrorMessage);
ListenButton.IsEnabled = true;
DisconnectButton.IsEnabled = false;
return;
}
rootPage.NotifyUser("Listening for incoming connections", NotifyType.StatusMessage);
}
private async void listener_Click(object sender, RoutedEventArgs e)
{
StreamSocketListener streamSocketListener = new StreamSocketListener();
streamSocketListener.ConnectionReceived += streamSocketListener_ConnectionReceived;
try
{
await streamSocketListener.BindServiceNameAsync("22112");
msgList.Children.Add(new TextBlock { Text = "监听成功" });
}
catch (Exception err)
{
if (SocketError.GetStatus(err.HResult) == SocketErrorStatus.AddressAlreadyInUse)
{
}
}
}
public override void Start()
{
if (Status == ListenerStatus.Listening)
return;
Task.Factory.StartNew(async () =>
{
try
{
_listener = new StreamSocketListener();
_listener.ConnectionReceived += ListenerOnConnectionReceived;
await _listener.BindServiceNameAsync(Endpoint.Port.ToString()).AsTask().ConfigureAwait(false);
RaiseStatusChanged(ListenerStatus.Listening);
}
catch
{
RaiseStatusChanged(ListenerStatus.PortNotFree);
}
});
}
public async Task<bool> StartServer()
{
Listener = new StreamSocketListener();
// Removes binding first in case it was already bound previously.
Listener.ConnectionReceived -= Listener_ConnectionReceived;
Listener.ConnectionReceived += Listener_ConnectionReceived;
try
{
await Listener.BindServiceNameAsync("4555"); // Your port goes here.
if(globalDataSet.DebugMode) Debug.Write("Server started \n");
return true;
}
catch (Exception ex)
{
Listener.ConnectionReceived -= Listener_ConnectionReceived;
Listener.Dispose();
return false;
}
}
//
// Constructor
//
public CommandServer(ICommandServerListener listener, CommmandServerMode mode, string ipAddress = "")
{
if (listener == null)
{
throw new Exception("The listener can't be null!");
}
m_listener = listener;
m_mode = mode;
// This the setup on a new task
new Task(async () =>
{
try
{
if (mode == CommmandServerMode.Server)
{
// Bind the socket
m_socketListener = new StreamSocketListener();
m_socketListener.ConnectionReceived += SocketAccpet;
await m_socketListener.BindServiceNameAsync("" + GLOW_SERVER_PORT);
}
else
{
if(ipAddress == null)
{
throw new Exception("The Ip address can't be empty!");
}
// Open the socket
m_socket = new StreamSocket();
await m_socket.ConnectAsync(new Windows.Networking.HostName(ipAddress), GLOW_SERVER_PORT + "");
// Start the listener
ServiceSocket(m_socket);
}
}
catch(Exception e)
{
System.Diagnostics.Debug.WriteLine("Socket Create Failed: " + e.Message);
m_listener.OnFatalError();
}
}).Start();
}
public async void StartAsync()
{
try
{
//Create a new Cancel Token
_cancel = new CancellationTokenSource();
_listener = new StreamSocketListener();
//Assinged event when have a new connection
_listener.ConnectionReceived += Listener_ConnectionReceived;
//Bind port
await _listener.BindServiceNameAsync(_port.ToString());
}
catch (Exception e)
{
InvokeOnError(e.Message);
}
}
private async void StartServer()
{
try
{
var streamSocketListener = new Windows.Networking.Sockets.StreamSocketListener();
// The ConnectionReceived event is raised when connections are received.
streamSocketListener.ConnectionReceived += this.StreamSocketListener_ConnectionReceived;
// Start listening for incoming TCP connections on the specified port. You can specify any port that's not currently in use.
await streamSocketListener.BindServiceNameAsync(PortNumber);
serverStatus = ServerStatus.Started;
}
catch (Exception ex)
{
Windows.Networking.Sockets.SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
}
}
public async Task<bool> Initialize()
{
bool success = true;
try
{
//set up a listener socket for speakers to connect with
_listener = new StreamSocketListener();
_listener.Control.KeepAlive = true;
_listener.Control.QualityOfService = SocketQualityOfService.LowLatency;
_listener.ConnectionReceived += Listener_ConnectionReceived;
await _listener.BindServiceNameAsync(SERVICE_NAME);
}
catch (Exception ex)
{
Debug.WriteLine("Error: " + ex);
success = false;
}
return success;
}
private async void StartServer()
{
try
{
var streamSocketListener = new Windows.Networking.Sockets.StreamSocketListener();
// The ConnectionReceived event is raised when connections are received.
streamSocketListener.ConnectionReceived += this.StreamSocketListener_ConnectionReceived;
// Start listening for incoming TCP connections on the specified port. You can specify any port that's not currently in use.
await streamSocketListener.BindServiceNameAsync(StreamSocketAndListenerPage.PortNumber);
this.serverListBox.Items.Add("server is listening...");
}
catch (Exception ex)
{
Windows.Networking.Sockets.SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
this.serverListBox.Items.Add(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
}
}
public async Task<bool> Start()
{
StreamSocketListener listener = new StreamSocketListener();
listener.ConnectionReceived += OnConnection;
// Start listen operation.
try
{
await listener.BindServiceNameAsync(_port.ToString());
}
catch (Exception exception)
{
// If this is an unknown status it means that the error is fatal and retry will likely fail.
if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
{
return false;
}
}
return true;
}
// Use this for initialization
#if !WINDOWS_UWP
void Start()
{
#endif
#if WINDOWS_UWP
async void Start()
{
try
{
socketListener = new Windows.Networking.Sockets.StreamSocketListener();
socketListener.ConnectionReceived += SocketListener_ConnectionReceived;
await socketListener.BindServiceNameAsync("1337");
}
catch (Exception e)
{
counttext.text = "Error: " + e.ToString();
}
#endif
}
void Update()
{
errortext.text = request + " " + hand.transform.localEulerAngles.y;
float a = 0;
missiontext.text = "Request not received yet";
/*if (!request.Equals("Request not received yet")) {
if (Tutorialed == false) {
missiontext.text = "Keep using your maximum strength. Tutorial Part";
double tutorial = Double.Parse(request);
if (Time.deltaTime > 1 && Time.deltaTime < 5)
{
errortext.text = " " + Time.deltaTime + " : Tutorial Part";
counttext.text = (5 - Time.deltaTime) + " seconds left in tutorial part";
if (EMGMaximum < tutorial)
{
EMGMaximum = tutorial;
}
}
Tutorialed = true;
startgametime = Time.deltaTime;
}
if (Tutorialed == true) {
{
try
{
double data = Double.Parse(request);
if ((Time.time - startgametime) % 10 < 2 && ((Time.time - startgametime)) < 300)
{
missiontext.text = "Prepare to shoot in 2 seconds.";
counttext.text = "Count down " + (2 - (Time.time - startgametime) % 10);
}
if (((Time.time - startgametime) % 10) >= 2 && ((Time.time - startgametime) % 10) < 5 && ((Time.time - startgametime)) < 300)
{
missiontext.text = "Use your MAXIMUM strength now~";
counttext.text = "Count down " + (5 - (Time.time - startgametime) % 10);
Progressslide.value += ToSingle(0.03);
if (data > EMGtemp)
{
EMGtemp = data;
}
if (data > EMGMaximum)
{
EMGMaximum = data;
}
}
if (((Time.time - startgametime) % 10) >= 5 && ((Time.time - startgametime) % 10) < 10 && ((Time.time - startgametime)) < 300 && ((Time.time - startgametime)) > nextFire)
{
missiontext.text = "Shooting";
counttext.text = "Count down " + (10 - (Time.time - startgametime) % 10);
nextFire = ToSingle(Time.time - startgametime) + fireRate;
if (EMGtemp > EMGMaximum * 0.8)
{
ThrowNewBallSuccess();
Success = Success + 1;
}
if (EMGtemp <= EMGMaximum * 0.8)
{
ThrowNewBallFail();
}
if ((hand.transform.localEulerAngles.y <= 50 && hand.transform.localEulerAngles.y >= 0) ||
(hand.transform.localEulerAngles.y >= 300 && hand.transform.localEulerAngles.y <= 360))
{
hand.transform.Rotate(0.0f, a + (float)EMGtemp, 0.0f);
}
else
{
if (hand.transform.localEulerAngles.y > 50 && hand.transform.localEulerAngles.y < 180)
{
hand.transform.localEulerAngles = new Vector3(
0.0f,
50f,
0.0f
);
}
if (hand.transform.localEulerAngles.y < 300 && hand.transform.localEulerAngles.y > 180)
{
hand.transform.localEulerAngles = new Vector3(
0.0f,
300f,
0.0f
);
}
}
}
else if ((Time.time - startgametime) >= 300)
{
missiontext.text = "CONGRATULATIONS! You shot " + Success + " out of 30 balls!";
counttext.text = "Thank you for playing";
Progressslide.value = 1;
}
}
catch (Exception e) {
errortext.text = "Error: " + e.ToString();
}
}
a = hand.transform.localEulerAngles.y;
}
}
*/
}
