/// <summary>
/// <see cref="AsyncTask.DoInBackground(Java.Lang.Object[])"/>
/// </summary>
override protected Java.Lang.Object DoInBackground(params Java.Lang.Object[] @params)
{
ServerSocket serverSocket = new ServerSocket(m_Port);
Socket clientSocket = serverSocket.Accept();
int res;
List <byte> buffer = new List <byte>();
while ((res = clientSocket.InputStream.ReadByte()) != -1)
{
buffer.Add((byte)res);
}
m_Activity.RunOnUiThread(() =>
{
Toast.MakeText(m_Activity, $"Message received : {System.Text.Encoding.UTF8.GetString(buffer.ToArray())}", ToastLength.Short).Show();
});
DataOutputStream outputStream = new DataOutputStream(clientSocket.OutputStream);
outputStream.WriteUTF("Merci !");
outputStream.Close();
m_Activity.RunOnUiThread(() =>
{
Toast.MakeText(m_Activity, $"Message sent : Merci !", ToastLength.Short).Show();
});
serverSocket.Close();
return(null);
}
protected override Java.Lang.Object DoInBackground(params Java.Lang.Object[] @params)
{
ServerSocket serverSocket = null;
Socket client = null;
string Received = "";
try
{
if (serverSocket == null)
{
serverSocket = new ServerSocket(8888);
client = serverSocket.Accept();
}
var inputstream = client.InputStream;
StreamReader reader = new StreamReader(inputstream);
string text = reader.ReadToEnd();
serverSocket.Close();
serverSocket = null;
client = null;
}
catch (Java.Lang.Exception ex)
{
return(ex.Message);
}
return(Received);
}
//// Public Methods
/// <summary>Runs this named entity recognizer server.</summary>
public virtual void Run()
{
Socket client = null;
while (true)
{
try
{
client = listener.Accept();
if (Debug)
{
log.Info("Accepted request from ");
log.Info(client.GetInetAddress().GetHostName());
}
new NERServer.Session(this, client);
}
catch (Exception e1)
{
log.Info("NERServer: couldn't accept");
Sharpen.Runtime.PrintStackTrace(e1, System.Console.Error);
try
{
client.Close();
}
catch (Exception e2)
{
log.Info("NERServer: couldn't close client");
Sharpen.Runtime.PrintStackTrace(e2, System.Console.Error);
}
}
}
}
public void Run()
{
try
{
var server = new ServerSocket(1337)
{
ReceiveBufferSize = 50000
};
var clientCount = 0;
while (true)
{
var socket = server.Accept();
var builder = new StringBuilder();
builder.Append("clientThread-");
builder.Append(clientCount++);
var client = new Client(socket, builder.ToString());
client.Start();
}
}
catch (Exception e)
{
Log.Debug("Offliine", e.Message);
}
}
private void _Listen()
{
_ServerSocket.Listen(5);
while (true)
{
Socket s = ServerSocket.Accept();
ThreadPool.QueueUserWorkItem(new WaitCallback(HandleClient), s);
}
}
private void startControlAccept()
{
while (controlAccept)
{
Console.WriteLine("StartControlAccept");
Socket controlClient = controlServer.Accept();
Console.WriteLine("控制客户端IP地址:" + controlClient.RemoteEndPoint);
AddClient(controlClient, 1);
}
}
Task listenProcess() => Task.Run(() =>
{
Log.RecordEvent(this, $"TCP/IP listener started on port {l.LocalPort}.", LogEntrySeverity.Info);
var n = new EncryptionNegotiator();
while (process)
{
var s = l.Accept();
new ErebusLink(n.Negotiate(new SplitStream(s.InputStream, s.OutputStream)), ei, true);
}
});
private void startHeartAccept()
{
while (heartListenning)
{
Console.WriteLine("StartHeartAccept");
Socket heartClient = heartServer.Accept(); //在等待时，可能会被强制终止
Console.WriteLine("心跳客户端IP地址:" + heartClient.RemoteEndPoint);
AddSocket(heartClient, 4);
}
}
private void startVideoAccept()
{
while (videoListenning)
{
Console.WriteLine("StartVideoAccept");
Socket videoClient = videoServer.Accept(); //在等待时，可能会被强制终止
Console.WriteLine("视频客户端IP地址:" + videoClient.RemoteEndPoint);
AddSocket(videoClient, 2); //向容器添加一个客户端
}
}
private void startPhotoAccept()
{
while (photoListenning)
{
Console.WriteLine("StartPhotoAccept");
Socket photoClient = photoServer.Accept(); //在等待时，可能会被强制终止
Console.WriteLine("图像客户端IP地址:" + photoClient.RemoteEndPoint);
AddSocket(photoClient, 3);
}
}
private void startControlAccept()
{
while (controlListenning)
{
Console.WriteLine("StartControlAccept");
Socket controlClient = controlServer.Accept(); //在等待时，可能会被强制终止
Console.WriteLine("控制客户端IP地址:" + controlClient.RemoteEndPoint);
AddSocket(controlClient, 1);
}
}
private void startVideoAccept()
{
while (videoAccept)
{
Console.WriteLine("StartVideoAccept");
Socket videoClient = videoServer.Accept();
Console.WriteLine("视频客户端IP地址:" + videoClient.RemoteEndPoint);
AddClient(videoClient, 2);
}
}
public void HandleIncomingConnections()
{
//List<ServerThread> serverThreads = new List<ServerThread>();
Task.Run(() =>
{
try
{
// Create the ServerSocket
serverSocket = new ServerSocket();
var sAddr = new InetSocketAddress(Port);
serverSocket.ReuseAddress = true;
serverSocket.Bind(sAddr);
Log.Debug(_tag, $"Server listening on {Port}.");
while (!_cts.IsCancellationRequested)
{
// Grab the next incoming connection
Socket socket = serverSocket.Accept();
Log.Debug(_tag, $"Server accepted a connection from {socket.InetAddress.CanonicalHostName}.");
lock (_lock)
{
// Cache the socket, filed under its address
connections[socket.InetAddress.CanonicalHostName] = socket;
//// Create and cache a DataOutputStream for sending data over it
//var dOutStream = new DataOutputStream(socket.OutputStream);
// outputStreams.Add(socket, dOutStream);
}
// Create a new thread for this connection
serverThreads[socket.InetAddress.CanonicalHostName] = new ServerThread(this, socket).Start();
//// Ack back to the connection to let it know you're hearing it (and to pass it the address you'll know it by)
//ForwardTo(socket.InetAddress.CanonicalHostName, GROUPSERVER, ACK + CONNECTED_AS + socket.InetAddress.CanonicalHostName);
}
}
catch (Exception e)
{
Log.Debug(_tag, $"Exception in server socket listening: \n{e}\n");
}
finally
{
Log.Debug(_tag, $"Releasing all connections ({serverThreads.Count} of them).");
serverSocket.Close();
foreach (var sThread in serverThreads.Values)
{
sThread.Stop();
}
}
});
}
/// <summary>
/// <see cref="AsyncTask.DoInBackground(Java.Lang.Object[])"/>
/// </summary>
protected override Java.Lang.Object DoInBackground(params Java.Lang.Object[] @params)
{
ServerSocket serverSocket = new ServerSocket(m_Port);
Socket clientSocket = serverSocket.Accept();
DataOutputStream outputStream = new DataOutputStream(clientSocket.OutputStream);
outputStream.WriteUTF("Coucou");
outputStream.Flush();
return(null);
}
public Server()
{
isRunning = false;
_clients = new Dictionary <string, Socket>();
ServerSocket = new ServerSocket(this);
ServerSocket.Bind(8888);
ServerSocket.Listen(500);
ServerSocket.Accept();
if (ServerSocket._socket.Connected)
{
isRunning = true;
}
}
public void Run() {
Log.Info(TAG,"RTSP server listening on port "+mServer.LocalPort);
while (!Java.Lang.Thread.Interrupted()) {
try {
new WorkerThread(mServer.Accept()).start();
} catch (SocketException e) {
break;
} catch (IOException e) {
Log.Error(TAG,e.Message);
continue;
}
}
Log.Info(TAG,"RTSP server stopped !");
}
public static void Run()
{
if (System.IO.File.Exists("Config-Auth.xml") == false)
{
return;
}
TextReader configReader = File.OpenText("Config-Auth.xml");
if (configReader == null)
{
throw new Exception("Unable to open Config-Auth.xml");
}
var doc = new XmlDocument();
var xmlReader = XmlReader.Create(configReader);
doc.Load(xmlReader);
var els = doc.GetElementsByTagName("AuthServer");
if (els.Count == 0)
{
throw new Exception("Config-Auth.xml does not contain element AuthServer");
}
var el = els[0] as XmlElement;
string port = el.GetAttribute("Port");
if (port == null)
{
throw new Exception("Config-Auth.xml does not define AuthServer port");
}
string listenbacklog = el.GetAttribute("ListenBacklog");
//just some test setup for now
LogonPacketHandler.Init();
MainSocket = new Networking.ServerSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
MainSocket.SetProcessor(new LogonPacketProcessor());
MainSocket.Bind(ushort.Parse(port));
MainSocket.Listen(listenbacklog == null ? 50 : int.Parse(listenbacklog));
MainSocket.Accept();
Running = true;
}
/// <summary>
/// Run a very simple server.
/// </summary>
private void RunServer()
{
try
{
Log.I("SimpleHttpServer", "Creating server socket");
var serverSocket = new ServerSocket(PORT);
var requestCount = 0;
try
{
while (!stop)
{
Log.I("SimpleHttpServer", "Waiting for connection");
var socket = serverSocket.Accept();
var input = new BufferedReader(new InputStreamReader(socket.GetInputStream()));
var output = new BufferedWriter(new OutputStreamWriter(socket.GetOutputStream()));
string line;
Log.I("SimpleHttpServer", "Reading request");
while ((line = input.ReadLine()) != null)
{
Log.I("SimpleHttpServer", "Received: " + line);
if (line.Length == 0)
{
break;
}
}
Log.I("SimpleHttpServer", "Sending response");
output.Write("HTTP/1.1 200 OK\r\n");
output.Write("\r\n");
output.Write(string.Format("Hello world {0}\r\n", requestCount));
output.Flush();
socket.Close();
requestCount++;
}
}
finally
{
serverSocket.Close();
}
}
catch (Exception ex)
{
Log.E("SimpleHttpServer", "Connection error", ex);
}
}
/// <summary>
/// Application method to run the server runs in an infinite loop
/// listening on port 9898.
/// </summary>
/// <remarks>
/// Application method to run the server runs in an infinite loop
/// listening on port 9898. When a connection is requested, it
/// spawns a new thread to do the servicing and immediately returns
/// to listening. The server keeps a unique client number for each
/// client that connects just to show interesting logging
/// messages. It is certainly not necessary to do this.
/// </remarks>
/// <exception cref="System.IO.IOException"/>
public static void Main(string[] args)
{
System.Console.Out.WriteLine("The modeling server is running.");
int clientNumber = 0;
ServerSocket listener = new ServerSocket(9898);
try
{
while (true)
{
new TextAnnotationPatternsInterface.PerformActionUpdateModel(listener.Accept(), clientNumber++).Start();
}
}
finally
{
listener.Close();
}
}
public static void Start(int port)
{
//if (ServerSocket != null && ServerSocket.Connected)
//{
// ServerSocket.Disconnect(false);
//}
try
{
ServerSocket.Bind(port);
ServerSocket.Listen(500);
ServerSocket.Accept();
Logger.LogEvent("Start listening on " + port);
}
catch (Exception ex)
{
Logger.LogError("Error start listening on " + port + " | " + ex.Message);
}
IsStarted = true;
}
//接受客户端连接的方法
private void RecieveAccept()
{
while (true)
{
//Accept 以同步方式从侦听套接字的连接请求队列中提取第一个挂起的连接请求，然后创建并返回新的 Socket。
//在阻止模式中，Accept 将一直处于阻止状态，直到传入的连接尝试排入队列。连接被接受后，原来的 Socket 继续将传入的连接请求排入队列，直到您关闭它。
byte[] buffer = new byte[65535];
ClientSocket[ClientNumb] = ServerSocket.Accept();
ClientSocket[ClientNumb].BeginReceive(buffer, 0, buffer.Length, SocketFlags.None,
new AsyncCallback(RecieveCallBack), ClientSocket[ClientNumb]);
//lock (this.ClientList)
//{
// this.ClientList.Items.Add(ClientSocket[ClientNumb].RemoteEndPoint.ToString() + " 成功连接服务器.");
//}
ReceiveAction(encoding.GetString(buffer));
分配id(ClientNumb);
ClientNumb++;
}
}
//ゲストからの接続を待つ処理
public void connect()
{
try
{
//ServerSocketを生成する
serverSocket = new ServerSocket(tcpPort);
//ゲストからの接続が完了するまで待って処理を進める
connectedSocket = serverSocket.Accept();
//この後はconnectedSocketに対してInputStreamやOutputStreamを用いて入出力を行ったりするが、ここでは割愛
}
catch (SocketException e)
{
e.PrintStackTrace();
}
catch (IOException e)
{
e.PrintStackTrace();
}
}
/// <summary>Tcp
/// ①ゲストからの接続を待つ処理
/// </summary>
public async Task createReceiveTcpSocket()
{
try
{
//ServerSocketを生成する
serverSocket = new ServerSocket(tcpPort);
//ゲストからの接続が完了するまで待って処理を進める
connectedSocket = await Task.Run(() => serverSocket.Accept());
//この後はconnectedSocketに対してInputStreamやOutputStreamを用いて入出力を行ったりするが、ここでは割愛
}
catch (SocketException e)
{
e.PrintStackTrace();
}
catch (IOException e)
{
e.PrintStackTrace();
}
}
//ゲストからの接続を待つ処理
public async Task <string> WaitToGuestConnect()
{
Adr = GetLocalIPAddress();
//return Adr;
try
{
//ServerSocketを生成する
serverSocket = new ServerSocket(tcpPort);
//ゲストからの接続が完了するまで待って処理を進める
connectedSocket = await Task.Run(() => serverSocket.Accept());
//この後はconnectedSocketに対してInputStreamやOutputStreamを用いて入出力を行ったりするが、ここでは割愛
}
catch (SocketException e)
{
e.PrintStackTrace();
}
catch (IOException e)
{
e.PrintStackTrace();
}
return(Adr.ToString());
}
/// <summary>
/// Runs in a loop, getting requests from new clients until a client
/// tells us to exit.
/// </summary>
/// <exception cref="System.IO.IOException"/>
public virtual void Listen()
{
while (stillRunning)
{
Socket clientSocket = null;
try
{
clientSocket = serverSocket.Accept();
log.Info("Got a connection");
ProcessRequest(clientSocket);
log.Info("Goodbye!");
log.Info();
}
catch (IOException e)
{
// accidental multiple closes don't seem to have any bad effect
clientSocket.Close();
log.Info(e);
continue;
}
}
serverSocket.Close();
}
private void ListenerThread()
{
try
{
ServerSocket.Listen(backlog);
while (!Quitting)
{
try
{
Socket clientSocket = ServerSocket.Accept();
if (clientSocket != null)
{
var clientThread = new Thread(ClientThread);
clientThread.Start(clientSocket);
}
}
catch (SocketException ex)
{
if (ex.SocketErrorCode != SocketError.WouldBlock)
{
throw ex;
}
else
{
Thread.Sleep(5);
}
}
}
}
catch (Exception ex)
{
ListenerException = ex;
}
}
private static void Listen()
{
serverSocket = new ServerSocket(10010);
listening = true;
while (true)
{
Socket socket;
try
{
socket = serverSocket.Accept();
}
catch (Exception)
{
return;
}
StreamReader reader = new StreamReader(socket.InputStream);
string message = reader.ReadLine();
if (message != null)
{
if (message == "REQUEST_ORDERS")
{
SendOrders(socket);
}
else if (message == "UPDATES_START")
{
RecieveUpdates(socket);
}
}
reader.Close();
socket.Close();
}
}
public void OnConnectionInfoAvailable(WifiP2pInfo info)
{
if (_progressDialog != null && _progressDialog.IsShowing)
{
_progressDialog.Dismiss();
}
_info = info;
View.Visibility = ViewStates.Visible;
// The owner IP is now known.
var view = _contentView.FindViewById <TextView>(Resource.Id.group_owner);
view.Text = Resources.GetString(Resource.String.group_owner_text)
+ ((info.IsGroupOwner) ? Resources.GetString(Resource.String.yes)
: Resources.GetString(Resource.String.no));
// InetAddress from WifiP2pInfo struct.
view = _contentView.FindViewById <TextView>(Resource.Id.device_info);
view.Text = "Group Owner IP - " + _info.GroupOwnerAddress.HostAddress;
// After the group negotiation, we assign the group owner as the file
// server. The file server is single threaded, single connection server
// socket.
if (_info.GroupFormed && _info.IsGroupOwner)
{
Task.Factory.StartNew(() =>
{
try
{
var serverSocket = new ServerSocket(8988);
Log.Debug(WiFiDirectActivity.Tag, "Server: Socket opened");
var client = serverSocket.Accept();
Log.Debug(WiFiDirectActivity.Tag, "Server: connection done");
var f = new File(Environment.ExternalStorageDirectory + "/"
+ Activity.PackageName + "/wifip2pshared-" + DateTime.Now.Ticks + ".jpg");
var dirs = new File(f.Parent);
if (!dirs.Exists())
{
dirs.Mkdirs();
}
f.CreateNewFile();
Log.Debug(WiFiDirectActivity.Tag, "Server: copying files " + f);
var inputStream = client.InputStream;
CopyFile(inputStream, new FileStream(f.ToString(), FileMode.OpenOrCreate));
serverSocket.Close();
return(f.AbsolutePath);
}
catch (IOException e)
{
Log.Error(WiFiDirectActivity.Tag, e.Message);
return(null);
}
})
.ContinueWith(result =>
{
if (result != null)
{
_contentView.FindViewById <TextView>(Resource.Id.status_text).Text = "File copied - " +
result.Result;
var intent = new Intent();
intent.SetAction(Intent.ActionView);
intent.SetDataAndType(Android.Net.Uri.Parse("file://" + result.Result), "image/*");
Activity.StartActivity(intent);
}
});
}
else if (_info.GroupFormed)
{
_contentView.FindViewById <Button>(Resource.Id.btn_start_client).Visibility = ViewStates.Visible;
_contentView.FindViewById <TextView>(Resource.Id.status_text).Text =
Resources.GetString(Resource.String.client_text);
}
_contentView.FindViewById <Button>(Resource.Id.btn_connect).Visibility = ViewStates.Gone;
}
public void Start()
{
stopped = false;
mappingStrategy.Load();
pool = new ThreadPool("AGIServer", poolSize);
#if LOGGER
logger.Info("Thread pool started.");
#endif
try
{
var ipAddress = IPAddress.Parse(address);
serverSocket = new ServerSocket(port, ipAddress, SocketEncoding);
}
catch (IOException ex)
{
#if LOGGER
logger.Error("Unable start AGI Server: cannot to bind to " + address + ":" + port + ".", ex);
#endif
throw ex;
}
finally
{
if (serverSocket != null)
{
serverSocket.Close();
serverSocket = null;
}
pool.Shutdown();
#if LOGGER
logger.Info("AGIServer shut down.");
#endif
}
#if LOGGER
logger.Info("Listening on " + address + ":" + port + ".");
#endif
try
{
SocketConnection socket;
while ((socket = serverSocket.Accept()) != null)
{
#if LOGGER
logger.Info("Received connection.");
#endif
var connectionHandler = new AGIConnectionHandler(socket, mappingStrategy, SC511_CAUSES_EXCEPTION,
SCHANGUP_CAUSES_EXCEPTION);
pool.AddJob(connectionHandler);
}
}
catch (IOException ex)
{
if (!stopped)
{
#if LOGGER
logger.Error("IOException while waiting for connections (1).", ex);
#endif
throw ex;
}
}
finally
{
if (serverSocket != null)
{
try
{
serverSocket.Close();
}
#if LOGGER
catch (IOException ex)
{
logger.Error("IOException while waiting for connections (2).", ex);
}
#else
catch { }
#endif
}
serverSocket = null;
pool.Shutdown();
#if LOGGER
logger.Info("AGIServer shut down.");
#endif
}
}
public async Task ServerConnect1()
{
ServerSocket serverSocket = null;
try
{
serverSocket = await Task.Run(() => new Java.Net.ServerSocket(0));
bool runFlag = true;
while (runFlag)
{
//System.out.println("start wait...");
System.Console.WriteLine("start wait...");
// 接続があるまでブロック
Socket socket = await Task.Run(() => serverSocket.Accept());
BufferedReader br = new BufferedReader(new InputStreamReader(socket.InputStream));
string str = await Task.Run(() => br.ReadLine());
while ((str) != null)
{
//System.out.println(str);
System.Console.WriteLine(str);
// exitという文字列を受け取ったら終了する
if ("exit".Equals(str))
{
runFlag = false;
}
}
if (socket != null)
{
socket.Close();
socket = null;
}
}
}
catch (IOException e)
{
e.PrintStackTrace();
Ans = e.ToString();
}
//if (serverSocket != null)
//{
// try
// {
// serverSocket.Close();
// serverSocket = null;
// }
// catch (IOException e)
// {
// e.PrintStackTrace();
// }
//}
}