Android Client-Server utilisant Sockets – Implémentation de serveur – Serveur d’impression
Dans cette série client / serveur Android utilisant Sockets post, nous allons nous concentrer sur la mise en œuvre côté serveur. Nous avons traité de la mise en œuvre côté client dans notre précédent article «Client-serveur Android utilisant des sockets – Mise en œuvre du client». Android possède un très vaste ensemble de bibliothèques permettant aux utilisateurs de mettre en œuvre des idées innovantes avec les bibliothèques fournies. Il est très facile de créer un serveur sous Android à l'aide de ces bibliothèques intégrées.
Sommaire
Détails d'implémentation
Dans ce tutoriel, nous utiliserons java Sockets pour réaliser notre communication serveur-client. D'un côté, il y aura un serveur qui se liera au port spécifié sur le périphérique et sera disponible pour le client en utilisant l'adresse IP et la combinaison de ports. Le client utilisera également un port aléatoire pour la connexion. Une fois la connexion établie du côté client, le serveur sera rejoué au client avec “Bonjour du serveur, vous êtes #%ré”% D sera un nombre qui augmentera avec chaque connexion.
[su_button url=”https://github.com/androidsrc/SocketServer” target=”blank” style=”stroked” background=”#51d461″ color=”#ffffff” size=”6″ center=”yes” radius=”0″ icon=”icon: arrow-circle-o-down”]Télécharger le code source complet[/su_button]
Remarque : Ce tutoriel est basé sur Android Studio 2.2, Java 1.6 et Android 6.0.
Mise en oeuvre du serveur
Implémentation de Server.java
Cette classe contient toute l'implémentation du serveur. Dans cette classe, nous allons créer un objet de "ServerSocket" dans un fil séparé. Acceptez() fonctionner dans ServerSocket attend une demande entrante et se bloque jusqu'à ce que la connexion soit ouverte. Cette méthode retourne un objet socket représentant la connexion qui vient d'être ouverte. L'adresse IP et le numéro de port du client peuvent être obtenus à partir de ce socket.
La classe privée SocketServerThread étend le thread {
int compte = 0;
@Passer outre
public void run () {
essayer
// crée ServerSocket en utilisant le port spécifié
serverSocket = new ServerSocket (socketServerPORT);
while (true)
// bloque l'appel jusqu'à ce que la connexion soit créée et retourne
// objet Socket
Socket socket = serverSocket.accept ();
compter ++;
message + = "#" + compte + "de"
+ socket.getInetAddress () + ":"
+ socket.getPort () + " n";
activity.runOnUiThread (new Runnable ()
@Passer outre
public void run ()
activity.msg.setText (message);
);
SocketServerReplyThread socketServerReplyThread =
new SocketServerReplyThread (socket, nombre);
socketServerReplyThread.run ();
catch (IOException e)
// TODO Bloc de capture généré automatiquement
e.printStackTrace ();
}
}
Ensuite, nous allons créer un objet de "SocketServerReplyThread" qui étend thread et nous passons socket et comptons au constructeur. Suivant obtenir OutputStream de Prise en utilisant getOutputStream () une fonction. UNE PrintStream est maintenant créé en utilisant OutputStream object en tant que nouveau flux d'impression ne vide pas automatiquement son contenu dans le flux cible lorsqu'une nouvelle ligne est rencontrée. Après cela nous impression() rejouer PrintStream et Courant est fermé. Huhh beaucoup de théorie.
La classe privée SocketServerReplyThread étend le thread {
Socket privé hostThreadSocket;
int cnt;
SocketServerReplyThread (Socket socket, int c)
hostThreadSocket = socket;
cnt = c;
@Passer outre
public void run ()
OutputStream outputStream;
String msgReply = "Bonjour du serveur, vous êtes #" + cnt;
essayer
outputStream = hostThreadSocket.getOutputStream ();
PrintStream printStream = new PrintStream (outputStream);
printStream.print (msgReply);
printStream.close ();
message + = "rejoué:" + msgReply + " n";
activity.runOnUiThread (new Runnable ()
@Passer outre
public void run ()
activity.msg.setText (message);
);
catch (IOException e)
// TODO Bloc de capture généré automatiquement
e.printStackTrace ();
message + = "Quelque chose ne va pas!" + e.toString () + " n";
activity.runOnUiThread (new Runnable ()
@Passer outre
public void run ()
activity.msg.setText (message);
);
}
Nous aurons enfin besoin d'une méthode pour obtenir l'adresse IP de notre serveur.
public String getIpAddress () {
String ip = "";
essayer
Énumération enumNetworkInterfaces = NetworkInterface
.getNetworkInterfaces ();
while (enumNetworkInterfaces.hasMoreElements ())
NetworkInterface networkInterface = enumNetworkInterfaces
.nextElement ();
Énumération enumInetAddress = networkInterface
.getInetAddresses ();
while (enumInetAddress.hasMoreElements ())
InetAddress inetAddress = enumInetAddress
.nextElement ();
if (inetAddress.isSiteLocalAddress ())
ip + = "Serveur tournant à:"
+ inetAddress.getHostAddress ();
catch (SocketException e)
// TODO Bloc de capture généré automatiquement
e.printStackTrace ();
ip + = "Quelque chose ne va pas!" + e.toString () + " n";
retourne ip;
}
Implémentation complète de la classe Server.java
package com.androidsrc.server;
importer java.io.IOException;
importer java.io.OutputStream;
importer java.io.PrintStream;
importer java.net.InetAddress;
importer java.net.NetworkInterface;
importer java.net.ServerSocket;
importer java.net.Socket;
importer java.net.SocketException;
importer java.util.Enumeration;
Classe publique Server {
Activité MainActivity;
ServerSocket serverSocket;
Message de chaîne = "";
static final int socketServerPORT = 8080;
serveur public (activité MainActivity)
this.activity = activité;
Thread socketServerThread = new Thread (nouveau SocketServerThread ());
socketServerThread.start ();
public int getPort ()
return socketServerPORT;
public void onDestroy ()
if (serverSocket! = null)
essayer
serverSocket.close ();
catch (IOException e)
// TODO Bloc de capture généré automatiquement
e.printStackTrace ();
La classe privée SocketServerThread étend le thread {
int compte = 0;
@Passer outre
public void run () {
essayer
// crée ServerSocket en utilisant le port spécifié
serverSocket = new ServerSocket (socketServerPORT);
while (true)
// bloque l'appel jusqu'à ce que la connexion soit créée et retourne
// objet Socket
Socket socket = serverSocket.accept ();
compter ++;
message + = "#" + compte + "de"
+ socket.getInetAddress () + ":"
+ socket.getPort () + " n";
activity.runOnUiThread (new Runnable ()
@Passer outre
public void run ()
activity.msg.setText (message);
);
SocketServerReplyThread socketServerReplyThread =
new SocketServerReplyThread (socket, nombre);
socketServerReplyThread.run ();
catch (IOException e)
// TODO Bloc de capture généré automatiquement
e.printStackTrace ();
}
}
La classe privée SocketServerReplyThread étend le thread {
Socket privé hostThreadSocket;
int cnt;
SocketServerReplyThread (Socket socket, int c)
hostThreadSocket = socket;
cnt = c;
@Passer outre
public void run ()
OutputStream outputStream;
String msgReply = "Bonjour du serveur, vous êtes #" + cnt;
essayer
outputStream = hostThreadSocket.getOutputStream ();
PrintStream printStream = new PrintStream (outputStream);
printStream.print (msgReply);
printStream.close ();
message + = "rejoué:" + msgReply + " n";
activity.runOnUiThread (new Runnable ()
@Passer outre
public void run ()
activity.msg.setText (message);
);
catch (IOException e)
// TODO Bloc de capture généré automatiquement
e.printStackTrace ();
message + = "Quelque chose ne va pas!" + e.toString () + " n";
activity.runOnUiThread (new Runnable ()
@Passer outre
public void run ()
activity.msg.setText (message);
);
}
public String getIpAddress () {
String ip = "";
essayer
Énumération enumNetworkInterfaces = NetworkInterface
.getNetworkInterfaces ();
while (enumNetworkInterfaces.hasMoreElements ())
NetworkInterface networkInterface = enumNetworkInterfaces
.nextElement ();
Énumération enumInetAddress = networkInterface
.getInetAddresses ();
while (enumInetAddress.hasMoreElements ())
InetAddress inetAddress = enumInetAddress
.nextElement ();
if (inetAddress.isSiteLocalAddress ())
ip + = "Serveur tournant à:"
+ inetAddress.getHostAddress ();
catch (SocketException e)
// TODO Bloc de capture généré automatiquement
e.printStackTrace ();
ip + = "Quelque chose ne va pas!" + e.toString () + " n";
retourne ip;
}
}
Implémentation de la classe MainActivity.java
L'utilisation de la classe de serveur est très simple. Il vous suffit de créer un objet de la classe Server et de passer l'instance MainActivity au constructeur, et vous avez terminé. Voici à quoi ressemble MainActivity.java.
package com.androidsrc.server; importer android.os.Bundle; importer android.app.Activity; importer android.widget.TextView; Classe publique MainActivity étend Activity Serveur serveur; TextView infoip, msg; @Passer outre Void protégé onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); infoip = (TextView) findViewById (R.id.infoip); msg = (TextView) findViewById (R.id.msg); server = new Server (this); infoip.setText (server.getIpAddress () + ":" + server.getPort ()); @Passer outre void protected onDestroy () super.onDestroy (); server.onDestroy ();
Autres composants de support
Implémentation du fichier activity_main.xml.
AndroidManifest.xml
Nous aurons besoin de la permission INTERNET pour créer des sockets. N'oubliez pas d'inclure cette autorisation dans votre manifeste.
Tester l'application
Pour tester cette application, installez-la sur un appareil Android et installez le client sur un autre appareil. Les deux appareils doivent être connectés au même réseau wifi. Ajoutez maintenant une adresse IP et un port au client, puis cliquez sur Connecter. Le serveur rejouera avec un message au client. Merci
Pour toute autre question ou tutoriel personnalisé, veuillez commenter ou nous envoyer un courrier électronique à l'adresse [email protected]
Commentaires
Laisser un commentaire