Sistema Client-Server tra Android e pc: Creazione delle Socket

Oggi implementeremo un sistema client- server tra android e pc, soffermandoci maggiormente sulla creazione delle socket.

Sul dispositivo android ci sarà la socket client che invierà dei dati, e parallelamente una socket server si occuperà di ricevere i dati inviati dal dispositivo.

Ma prima ripassiamo un attimo il meccanismo client server e la nozione generale di socket.

Ricordiamo brevemente il paradigma Client-Server: un programma chiamato Client richiede dei servizi ad un altro programma chiamato Server. Quest’ultimo è in ascolto di richieste da parte dei client, esegue tali richieste con le risorse che ha a disposizione, e rispedisce, se richiesto i risultati al client. Tali programmi possono risiedere anche su computer diversi: tutto questo è trasparente ad entrambi.

Il meccanismo di astrazione per la comunicazione in rete è rappresentato dal paradigma socket presentato per la prima volta nella Berkeley Software Distribution (BSD) della University of California a Berkeley.

Una socket è come una porta di comunicazione e non è molto diversa da una presa elettrica: tutto ciò che è in grado di comunicare tramite il protocollo standard TCP/IP, può collegarsi ad una socket e comunicare tramite questa porta di comunicazione, allo stesso modo in cui un qualsiasi apparecchio che funziona a corrente può collegarsi ad una presa elettrica e sfruttare la tensione messa a disposizione. Nel caso delle socket, invece dell’elettricità, nella rete viaggiano pacchetti TCP/IP. Tale protocollo e le socket forniscono quindi un’astrazione, che permette di far comunicare dispositivi diversi che utilizzano lo stesso protocollo.

Ovviamente Java mette a disposizione alcune classi per l’utilizzo delle socket, tra cui la classe Socket. Usando questa classe un client può stabilire un canale di comunicazione con un host remoto. Si potrà comunicare attraverso questo canale utilizzando stream particolari, specializzati per le socket.

AL LAVORO!

Il client su Android

La classe Client.java

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;

public class Client extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Socket socket = null;
DataOutputStream dataOutputStream = null;
DataInputStream dataInputStream = null;

try {

socket = new Socket(“192.168.0.1(sostituitelo con l’ip del vostro pc che farà da server)”, 10324);
dataOutputStream = new DataOutputStream(socket.getOutputStream());
dataInputStream = new DataInputStream(socket.getInputStream());
dataOutputStream.writeUTF(“Questa e’ una prova”);

} catch (UnknownHostException e) {

} catch (IOException e) {

}
finally{
if (socket != null){
try {
socket.close();
} catch (IOException e) {

}
}

if (dataOutputStream != null){
try {
dataOutputStream.close();
} catch (IOException e) {

}
}

if (dataInputStream != null){
try {
dataInputStream.close();
} catch (IOException e) {

}
}
}
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
}

Il file manifest.xml

Aggiungere il seguente permesso nel manifest:

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

Il file Client.xml

Il layout sarà davvero banale, infatti non appena invieremo l’app comparirà una schermata bianca e la socket invierà al server la stringa “questa e’ una prova”;

<RelativeLayout xmlns:android=”http://schemas.android.com/apk/res/android&#8221;
xmlns:tools=”http://schemas.android.com/tools&#8221;
android:layout_width=”match_parent”
android:layout_height=”match_parent”
tools:context=”.Client” >

</RelativeLayout>

Il server su pc:

Il server sarà composto soltanto di una semplice classe con una socket server, impostata sull’indirizzo ip del nostro pc, che leggerà la stringa inviata dalla socket client e la stamperà a video!

La classe Server.java

import java.net.*;
import java.io.*;
import java.util.*;
import java.awt.*;
public class Server{

public static void main(String[]args){

ServerSocket serverSock = null;
Socket cs = null;

System.err.println(“Socket Server”);
try {
serverSock = new ServerSocket(10324);
}
catch (IOException e) {
System.err.println(e.getMessage());
System.exit(1);
}

while (true) {
System.out.println(“Attesa connessione…”);
try {
cs = serverSock.accept();
}
catch (IOException e) {
System.out.println(“Connessione fallita”);
System.exit(2);
}

System.out.println(“Connessione da ” + cs);

try {
BufferedInputStream ib = new
BufferedInputStream(cs.getInputStream());
DataInputStream is = new DataInputStream(ib);
BufferedOutputStream ob = new
BufferedOutputStream(cs.getOutputStream());
PrintStream os = new PrintStream(ob,false);

String line;
line = new String(is.readLine());

//La stringa inizia dopo il secondo carattere
String comando_android_stringa=line.substring(2);

System.out.println(“Il client ha inviato questa stringa:”+comando_android_stringa);

os.close(); is.close(); cs.close();

}
catch (Exception e) {
System.out.println(“Errore: ” +e);
System.exit(3);
}

}
}
}

Bene, come vedete la porta che abbiamo impostato è la 10324 sia sul client che sul server, ricordatevi di inserire nel client l’indirzzo ip del server, e se avete seguito tutto per bene, una volta avviato il server e subito dopo il client su Android, vedrete comparire sul server la scritta “questa è una prova”.

Buon Lavoro!