android - studio - Cliente TCP realmente simple

socket android client to pc server

Question

Quiero que mi aplicación ingrese en la URL de mi servidor, por ejemplo, http://192.168.1.8/ y el puerto, por ejemplo, 1234 . Cuando mi servidor recibe el mensaje de Solicitud TCP, envía de vuelta un archivo (el servidor ya está implementado).

Creo que no necesito algo complicado como AsyncTask, ya que no quiero mantener la conexión. Al recibir la respuesta del servidor, mi conexión debe estar cerrada.

Cualquier indicación de un camino a seguir o una propina es muy apreciada.

Answer 1

Aquí hay un cliente TCP simple que usa Sockets que obtuve trabajando en base al código en este tutorial (el código del tutorial también se puede encontrar en este repositorio de GitHub ).

Tenga en cuenta que este código está orientado al envío de cadenas entre el cliente y el servidor, generalmente en formato JSON.

Aquí está el código del cliente TCP:

public class TcpClient {

    public static final String SERVER_IP = "192.168.1.8"; //server IP address
    public static final int SERVER_PORT = 1234;
    // message to send to the server
    private String mServerMessage;
    // sends message received notifications
    private OnMessageReceived mMessageListener = null;
    // while this is true, the server will continue running
    private boolean mRun = false;
    // used to send messages
    private PrintWriter mBufferOut;
    // used to read messages from the server
    private BufferedReader mBufferIn;

    /**
     * Constructor of the class. OnMessagedReceived listens for the messages received from server
     */
    public TcpClient(OnMessageReceived listener) {
        mMessageListener = listener;
    }

    /**
     * Sends the message entered by client to the server
     *
     * @param message text entered by client
     */
    public void sendMessage(String message) {
        if (mBufferOut != null && !mBufferOut.checkError()) {
            mBufferOut.println(message);
            mBufferOut.flush();
        }
    }

    /**
     * Close the connection and release the members
     */
    public void stopClient() {

        mRun = false;

        if (mBufferOut != null) {
            mBufferOut.flush();
            mBufferOut.close();
        }

        mMessageListener = null;
        mBufferIn = null;
        mBufferOut = null;
        mServerMessage = null;
    }

    public void run() {

        mRun = true;

        try {
            //here you must put your computer''s IP address.
            InetAddress serverAddr = InetAddress.getByName(SERVER_IP);

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

            //create a socket to make the connection with the server
            Socket socket = new Socket(serverAddr, SERVER_PORT);

            try {

                //sends the message to the server
                mBufferOut = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);

                //receives the message which the server sends back
                mBufferIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));


                //in this while the client listens for the messages sent by the server
                while (mRun) {

                    mServerMessage = mBufferIn.readLine();

                    if (mServerMessage != null && mMessageListener != null) {
                        //call the method messageReceived from MyActivity class
                        mMessageListener.messageReceived(mServerMessage);
                    }

                }

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

            } catch (Exception e) {

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

            } finally {
                //the socket must be closed. It is not possible to reconnect to this socket
                // after it is closed, which means a new socket instance has to be created.
                socket.close();
            }

        } catch (Exception e) {

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

        }

    }

    //Declare the interface. The method messageReceived(String message) will must be implemented in the MyActivity
    //class at on asynckTask doInBackground
    public interface OnMessageReceived {
        public void messageReceived(String message);
    }

}

Luego, declare un TcpClient como una variable miembro en su Actividad:

public class MainActivity extends Activity {

    TcpClient mTcpClient;

    //............

Luego, use una AsyncTask para conectarse a su servidor y recibir respuestas en el hilo de la interfaz de usuario ( onProgressUpdate() en cuenta que los mensajes recibidos del servidor se manejan en el método onProgressUpdate() que se reemplaza en AsyncTask):

public class ConnectTask extends AsyncTask<String, String, TcpClient> {

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

        //we create a TCPClient object
        mTcpClient = new TcpClient(new TcpClient.OnMessageReceived() {
            @Override
            //here the messageReceived method is implemented
            public void messageReceived(String message) {
                //this method calls the onProgressUpdate
                publishProgress(message);
            }
        });
        mTcpClient.run();

        return null;
    }

    @Override
    protected void onProgressUpdate(String... values) {
        super.onProgressUpdate(values);
        //response received from server
        Log.d("test", "response " + values[0]);
        //process server response here....

}

Para iniciar la conexión a su servidor, ejecute AsyncTask:

new ConnectTask().execute("");

Luego, enviando un mensaje al servidor:

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

Puede cerrar la conexión al servidor en cualquier momento:

if (mTcpClient != null) {
    mTcpClient.stopClient();
}

Answer 2

Gracias por el código. Pero tiene un problema con la recepción de datos ... por lo tanto, necesita poca actualización:

1. En el archivo TcpClient.java, el comando "run ()" debe reemplazarlo con un fragmento de código a continuación

   public void run () {

   mRun = true;
   
   try {
       InetAddress serverAddr = InetAddress.getByName(SERVER_IP);
       Log.e("TCP Client", "C: Connecting...");
       Socket socket = new Socket(serverAddr, SERVER_PORT);
       try {
           mBufferOut = new PrintWriter(socket.getOutputStream());
           Log.e("TCP Client", "C: Sent.");
           mBufferIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
           int charsRead = 0; char[] buffer = new char[1024]; //choose your buffer size if you need other than 1024
   
           while (mRun) {
               charsRead = mBufferIn.read(buffer);
               mServerMessage = new String(buffer).substring(0, charsRead);
               if (mServerMessage != null && mMessageListener != null) {
                   mMessageListener.messageReceived(mServerMessage);}
               mServerMessage = null;
           }
           Log.e("RESPONSE FROM SERVER", "S: Received Message: ''" + mServerMessage + "''"); 

// el resto del código está bien, vea el original

2. doInBackgroud en su MainActivity.java mensajes recibidos en onProgressUpdate, puede mostrarlo en otro objeto, por ejemplo, TextView

   @Override
   protected void onProgressUpdate(String... values) {
           super.onProgressUpdate(values);
           Log.d("test", "response " + values[0]);
           response.setText(response.getText() + "/n" +values[0]);
   } 

// "respuesta" es un objeto TextView declarado en tu función

public class MainActivity extends AppCompatActivity {
TextView response; //...so on

y función

protected void onCreate(Bundle savedInstanceState) { response = (TextView) findViewById(R.id.textView); //..so on