Como programar um servidor Java com um cliente Android usando Sockets?

Programar um servidor em Java que receba dados de um dispositivo Android é uma tarefa fácil, mas que poderá conter alguns problemas. Dado o “Curso Android” aos leitores (se estiver interessado, poderá começar aqui o curso, lendo a explicação do Android Studio), fica mais uma sugestão para criar um exemplo fácil e prático, usando Sockets.

Antes de mais, também deverá dar uma vista de olhos no curso de java que foi fornecido por nós, aqui (Primeiro Capítulo: Introdução ao NetBeans)

Como programar um servidor Java com um cliente Android usando Sockets?

Neste artigo iremos explicar como criar um servidor Java que aceita apenas um cliente Android. A comunicação será feita via sockets. O código, segue-se a seguir.

O código que se segue inclui os imports, a classe e as funções de inicialização do socket e seu buffer para receber mensagens. O servidor irá inicializar e ficar “à escuta” por uma nova mensagem.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;


public class Server {
    private ServerSocket server;
    private Socket client;
    private BufferedReader in;
    private String line;
    
    public Server(){
        line = "";
        listenSocket();
    }

    public void listenSocket() {
        // Colocar o porto em escuta (Porto = 4500)
        try {
            server = new ServerSocket(4500);
        } catch (IOException e) {
            System.out.println("Could not listen on port 4500");
            System.exit(-1);
        }
        writeInfo("Listen on Port 4500");
        
        
        //Aceitar cliente
        try {
            client = server.accept();
        } catch (IOException e) {
            System.out.println("Accept failed: 4500");
            System.exit(-1);
        }
        writeInfo("Client Accepted");

        //Preparar Buffers
        try {
            in = new BufferedReader(new InputStreamReader(client.getInputStream()));
        } catch (IOException e) {
            System.out.println("Read failed");
            System.exit(-1);
        }
        writeInfo("Buffereds Accepted");

        //Colocar o socket à escuta, à espera de mensagens do cliente
        while (true) {
            try {
                //Read message from client
                line = in.readLine();
                //Print message from client
                System.out.println("Message from client: " + line);
            } catch (IOException e) {
                System.out.println("Read failed: " + e.toString());
                System.exit(-1);
            }
        }
    }
}

O cliente que se segue é um cliente android que irá enviar uma mensagem para o servidor anteriormente mencionado.

Nota: Repare que existe uma parte do código que é necessário o IP (private static String IP;). Deverá substituir a palavra [IP] pelo IP da máquina onde o servidor irá correr. Para isso basta abrir a linha de comandos no seu computador e digitar o comando: “ipconfig“. Depois copie o IP que está à frente da linha “IPv4 Address

import android.os.AsyncTask;
import android.util.Log;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;


public class ClientConnection extends AsyncTask{
    // DEVE COLOCAR AQUI O IP DA SUA MÁQUINA
    private static String IP = "[IP]";
    private static int PORT = 4500;
    private Socket socket = null;
    private PrintWriter out = null;
    private BufferedReader in = null;

    public ClientConnection(){

    }

    @Override
    protected Object doInBackground(Object[] params) {
        try {
            socket = new Socket(IP, PORT);
            out = new PrintWriter(socket.getOutputStream(), true);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        }
        catch (IOException e) {
            Log.d("DEBUG ERROR", e.toString());
        }
        return null;
    }

    public boolean sendMessage(String message){
        out.println(message);
        return true;
    }

    private void closeAll(){
        try {
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Para o layout, basta inserir um botão que invoque a função mencionada no código anterior. A função é a “sendMessage”.

 <Button
        android:id="@+id/btnSendChallenge"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:onClick="sendMessage"
        android:text="Button"
        tools:layout_editor_absoluteX="147dp"
        tools:layout_editor_absoluteY="140dp"
        />

Para o código correr com sucesso, deverá ainda dar permissões ao dispositivo android para aceder a Internet. Por isso, abra o ficheiro “AndroidManifest.xml” que deverá estar dentro da pasta “app/manifests” e coloque as seguintes permissões:

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.INTERNET" />

A partir de agora deverá correr numa primeira fase o servidor e depois o cliente android.

Verifique que sempre que carrega no botão da sua aplicação Android, o servidor recebe uma mensagem.

Tem dúvidas? Algo deu errado? Interessado em mais exemplos? Porque não nos dá ideias sobre os mesmos?

Então deixe-nos o seu comentário.

Fonte das imagens