안드로이드 클라이언트를 C# 서버로 연결

Question

안드로이드 장치에서 PC로 데이터를 전송하여 작은 클라이언트 서버 (데이터를 보내려면 안드로이드 클라이언트)와 PC에 서버 (데이터 수신 및 인쇄)를 개발했습니다.) 나는 안드로이드 애플 리케이션을 닫고 다시 실행해야합니까? PC의 클라이언트 응용 프로그램이 제대로 작동하는 방식으로 클라이언트에서 전송할 수 있으며 서버는 안드로이드 클라이언트에서 수신 할 수 있습니다! 마지막으로 C# 서버 코드

public class TCPClient { 

    private String serverMessage; 
    public static final String SERVERIP = "192.168.0.104"; 
    public static final int SERVERPORT = 4444; 
    private OnMessageReceived mMessageListener = null; 
    private boolean mRun = false; 

    PrintWriter out; 
    BufferedReader in; 
    DataOutputStream dataOutputStream = null; 

    //OutputStream os; 

    public TCPClient(OnMessageReceived listener) { 
     mMessageListener = listener; 
    } 

    public void sendMessage(String message){ 
     if (out != null && !out.checkError()) { 

      /* 
      String toSend = "a"; 
      byte[] toSendBytes = toSend.getBytes(); 

      int toSendLen = toSendBytes.length; 
      byte[] toSendLenBytes = new byte[4]; 
      toSendLenBytes[0] = (byte)(toSendLen & 0xff); 
      toSendLenBytes[1] = (byte)((toSendLen >> 8) & 0xff); 
      toSendLenBytes[2] = (byte)((toSendLen >> 16) & 0xff); 
      toSendLenBytes[3] = (byte)((toSendLen >> 24) & 0xff); 
      try { 
       os.write(toSendLenBytes); 
      } catch (IOException e1) { 
       // TODO Auto-generated catch block 
       e1.printStackTrace(); 
      } 

      try { 
       os.write(toSendBytes); 
      } catch (IOException e) { 
       // TODO Auto-generated catch block 
       e.printStackTrace(); 
      } 
      */ 
      out.print(message);    
      out.flush();   


     } 
    } 

    public void stopClient(){ 
     mRun = false; 
    } 

    public void run() { 

     mRun = true; 

     try { 

      InetAddress serverAddr = InetAddress.getByName(SERVERIP); 

      Log.e("TCP Client", "C: Connecting..."); 

      Socket socket = new Socket(serverAddr, SERVERPORT);  

      /// 
      //os = socket.getOutputStream(); 

      if(socket.isBound()){ 
       Log.i("SOCKET", "Socket: Connected");    
      } 
      else{ 
       Log.e("SOCKET", "Socket: Not Connected"); 
      } 
      try { 

       out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true); 

       /* 
       dataOutputStream = new DataOutputStream(socket.getOutputStream()); 
       byte[] bytes = new byte[] {1}; 
       dataOutputStream.write(bytes, 0, bytes.length); 
       */ 
       Log.e("TCP Client", "C: Sent.");     

       Log.e("TCP Client", "C: Done."); 

       if(out.checkError()) 
       { 
        Log.e("PrintWriter", "CheckError"); 
       } 

       in = new BufferedReader(new InputStreamReader(socket.getInputStream())); 

       while (mRun) { 
        serverMessage = in.readLine(); 

        if (serverMessage != null && mMessageListener != null) { 
         mMessageListener.messageReceived(serverMessage); 
        } 
        serverMessage = null; 

       } 


       Log.e("RESPONSE FROM SERVER", "S: Received Message: '" + serverMessage + "'"); 


      } catch (Exception e) { 

       Log.e("TCP", "S: Error", e); 

      } finally { 

       socket.close(); 
      } 

     } catch (Exception e) { 

      Log.e("TCP", "C: Error", e); 

     } 

    } 

    public interface OnMessageReceived { 
     public void messageReceived(String message); 
    } 

} 

: 여기

class Program 
{ 
    static Socket listeningSocket; 
    static Socket socket; 
    static Thread thrReadRequest; 
    static int iPort = 4444; 
    static int iConnectionQueue = 100; 

    static void Main(string[] args) 
    { 
     Console.WriteLine(IPAddress.Parse(getLocalIPAddress()).ToString()); 
     try 
     {     
      listeningSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
      //listeningSocket.Bind(new IPEndPoint(0, iPort));         
      listeningSocket.Bind(new IPEndPoint(IPAddress.Parse(getLocalIPAddress()), iPort)); 
      listeningSocket.Listen(iConnectionQueue); 

      thrReadRequest = new Thread(new ThreadStart(getRequest)); 
      thrReadRequest.Start(); 
     } 
     catch (Exception e) 
     { 
      Console.WriteLine("Winsock error: " + e.ToString()); 
      //throw; 
     }    
    } 

    static private void getRequest() 
    { 
     int i = 0; 
     while (true) 
     { 
      i++; 
      Console.WriteLine("Outside Try i = {0}", i.ToString()); 

      try 
      { 
       socket = listeningSocket.Accept(); 

       // Receiving 
       //byte[] rcvLenBytes = new byte[4]; 
       //socket.Receive(rcvLenBytes); 
       //int rcvLen = System.BitConverter.ToInt32(rcvLenBytes, 0); 
       //byte[] rcvBytes = new byte[rcvLen]; 
       //socket.Receive(rcvBytes); 
       //String formattedBuffer = System.Text.Encoding.ASCII.GetString(rcvBytes); 

       byte[] buffer = new byte[socket.SendBufferSize]; 
       int iBufferLength = socket.Receive(buffer, 0, buffer.Length, 0); 
       Console.WriteLine("Received {0}", iBufferLength); 
       Array.Resize(ref buffer, iBufferLength); 
       string formattedBuffer = Encoding.ASCII.GetString(buffer); 

       Console.WriteLine("Data received by Client: {0}", formattedBuffer); 

       if (formattedBuffer == "quit") 
       { 
        socket.Close(); 
        listeningSocket.Close(); 
        Environment.Exit(0); 
       } 

       Console.WriteLine("Inside Try i = {0}", i.ToString()); 
       Thread.Sleep(500); 
      } 
      catch (Exception e) 
      { 
       //socket.Close(); 
       Console.WriteLine("Receiving error: " + e.ToString()); 
       Console.ReadKey(); 
       //throw; 
      } 

      finally 
      { 
       socket.Close(); 
       //listeningsocket.close(); 
      } 
     } 
    } 

    static private string getLocalIPAddress() 
    { 
     IPHostEntry host; 
     string localIP = ""; 
     host = Dns.GetHostEntry(Dns.GetHostName()); 
     foreach (IPAddress ip in host.AddressList) 
     { 
      if (ip.AddressFamily == AddressFamily.InterNetwork) 
      { 
       localIP = ip.ToString(); 
       break; 
      } 
     } 
     return localIP; 
    } 
} 

이 코드에 대한 링크입니다

public class MainActivity extends Activity { 

    private TCPClient mTcpClient; 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 
     final EditText editText = (EditText) findViewById(R.id.edit_message); 
     Button send = (Button)findViewById(R.id.send_button);   

     // connect to the server 
     new connectTask().execute(""); 

     send.setOnClickListener(new View.OnClickListener() { 
      @Override 
      public void onClick(View view) { 

       String message = editText.getText().toString(); 

       //sends the message to the server 
       if (mTcpClient != null) { 
        mTcpClient.sendMessage(message); 
       } 

       editText.setText(""); 
      } 
     }); 
    } 

    @Override 
    public boolean onCreateOptionsMenu(Menu menu) { 

     getMenuInflater().inflate(R.menu.main, menu); 
     return true; 
    } 

    public class connectTask extends AsyncTask<String,String,TCPClient> { 

     @Override 
     protected TCPClient doInBackground(String... message) { 

      mTcpClient = new TCPClient(new TCPClient.OnMessageReceived() { 
       @Override 

       public void messageReceived(String message) { 

        publishProgress(message); 
       } 
      }); 
      mTcpClient.run(); 

      return null; 
     } 

     @Override 
     protected void onProgressUpdate(String... values) { 
      super.onProgressUpdate(values); 
     } 
    } 
    } 

및하여 TcpClient 클래스 : 여기

은 안드로이드 코드 enter link description here

도움이 될까요?

Answer 1

이 수정 사항을 참조하십시오.

1)using fixed size messages . like we will send only 100 bytes . 
     and we will  receive only 100 bytes 

    2)dinamic way . size of message ,then the message itself . 
     like we will send [message.length][message] then on opposite side 
     we will receive the size message then read entire message 

    3) using marker . we will send message with end marker 
     (for example \n in our case) 
     we will use stream to read entire message sent to us till reaching that marker . 
     and most stream has readline() that will read till reaching \n 

당신이 두번째 방법을하고 싶어 생각 :

out.println(message);    
      out.flush(); 

C#을 읽기 이 할 수있는 3 가지 방법이 있습니다

socket = listeningSocket.Accept(); 
        using (NetworkStream nt = new NetworkStream(socket)) 
        { 
         using (StreamReader reader = new StreamReader(nt)) 
         { 
          string line; 
          string line; 

         // while ((line = reader.ReadLine()) != null)//as networkstream never got eof. was using it as replacement while(true)       // { 
          while (true) 
          { 
          try 
          { 
           line = reader.ReadLine(); 
          } 
          catch (IOException) 
          { 
           break; 
          } 
          Console.WriteLine(line); 
          } 
         }//using reader 
        }//using ns 

해야한다. 나는 그것에 무엇이 잘못되었는지 보려고 가까이서 보지 않았다. 그리고 플러스 u는이 옵션에 대한 주석을 달았습니다. 문제는 리틀 언 어언과 빅 덴디 언과 함께있을 수 있습니다.

Answer 2

약간의 재배치가있는 동일한 코드가 나를 위해 잘 작동합니다.

try 
    { 
     socket = listeningSocket.Accept(); 
     Console.WriteLine("Connectd..."); 
     while (true) 
     { 
      try 
      { 

       // Receiving 

       byte[] buffer = new byte[socket.SendBufferSize]; 
       int iBufferLength = socket.Receive(buffer, 0, buffer.Length, 0); 
       Console.WriteLine("Received {0}", iBufferLength); 
       Array.Resize(ref buffer, iBufferLength); 
       string formattedBuffer = Encoding.ASCII.GetString(buffer); 

       Console.WriteLine("Android Says: {0}", formattedBuffer); 

       if (formattedBuffer == "quit") 
       { 
        socket.Close(); 
        listeningSocket.Close(); 
        Console.WriteLine("Exiting"); 
        Environment.Exit(0); 
       } 

       //Console.WriteLine("Inside Try i = {0}", i.ToString()); 
       Thread.Sleep(500); 
      } 
      catch (Exception e) 
      { 
       //socket.Close(); 
       Console.WriteLine("Receiving error: " + e.ToString()); 
       Console.ReadKey(); 
       //throw; 
      } 


     } 
    } 
    catch (Exception e) 
    { 
     //socket.Close(); 
     Console.WriteLine("Error After Loop: " + e.ToString()); 
    } 
    finally 
    { 
     Console.WriteLine("Closing Socket"); 
     socket.Close(); 
     //listeningsocket.close(); 
    }