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