// Figure 17.5 : Client.java
// Définir un Client qui lit les informations envoyées
// à partir d'un Serveur et affiche les informations.

// Packages de noyau Java.
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;

// Packages d'extension Java.
import javax.swing.*;

public class Client extends JFrame {
   private JTextField champEntree;
   private JTextArea zoneAffichage;
   private ObjectOutputStream sortie;
   private ObjectInputStream entree;
   private String message = "";
   private String serveurDeChat;
   private Socket client;

   // Initialiser serveurDeChat et mettre en place la GUI.
   public Client( String hote ) {
      super( "Client" );

      // Ajuster le serveur auquel ce client se connecte.
      serveurDeChat = hote;

      Container conteneur = getContentPane();

      // Créer champEntree et inscrire l'écouteur.
      champEntree = new JTextField();
      champEntree.setEnabled( false );

      champEntree.addActionListener(

         new ActionListener() {

            // Envoyer le message au serveur.
            public void actionPerformed( ActionEvent evenement ) {
               envoyerDonnees( evenement.getActionCommand() );
            }

         }  // fin de classe interne anonyme

      ); // fin d'appel à addActionListener

      conteneur.add( champEntree, BorderLayout.NORTH );

      // Créer la zoneAffichage.
      zoneAffichage = new JTextArea();
      conteneur.add( new JScrollPane( zoneAffichage ),
         BorderLayout.CENTER );

      setSize( 330, 150 );
      setVisible( true );
   }

   // Se connecter au serveur et traiter les messages du serveur.
   public void lancerClient() {
      // Se connecter au serveur, obtenir les flux et traiter la connexion.
      try {

         // Étape 1 : créer un Socket pour établir la connexion.
         seConnecterAuServeur();

         // Étape 2 : obtenir les flux d'entrée et de sortie.
         obtenirLesFlux();

         // Étape 3 : traiter la connexion.
         traiterConnexion();

         // Étape 4 : fermer la connexion.
         fermerConnexion();
      }

      // Le serveur a fermé la connexion.
      catch ( EOFException eofException ) {
         System.out.println( "Le serveur a interrompu la connexion." );
      }

      // Traiter les problèmes de communication avec le serveur.
      catch ( IOException ioException ) {
         ioException.printStackTrace();
      }
   }

   // Obtenir les flux pour envoyer et recevoir les données.
   private void obtenirLesFlux() throws IOException
   {
      // Mettre en place le flux de sortie des objets.
      sortie = new ObjectOutputStream(
         client.getOutputStream() );

      // Vidanger tampon de sortie pour envoyer informations d'en-tête.
      sortie.flush();

      // Mettre en place le flux d'entrée pour les objets.
      entree = new ObjectInputStream(
         client.getInputStream() );

      zoneAffichage.append( "\nJ'ai reçu les flux d'E/S\n" );
   }

   // Se connecter au serveur.
   private void seConnecterAuServeur() throws IOException
   {
      zoneAffichage.setText( "Essai de connexion...\n" );

      // Créer le Socket pour mettre en place la connexion au serveur.
      client = new Socket(
         InetAddress.getByName( serveurDeChat ), 5000 );

      // Afficher les informations de connexion.
      zoneAffichage.append( "Connecté à : " +
         client.getInetAddress().getHostName() );
   }

   // Gérer la connexion au serveur.
   private void traiterConnexion() throws IOException
   {
      // Activer champEntree pour que l'utilisateur envoie des messages.
      champEntree.setEnabled( true );

      // Traiter les messages envoyés par le serveur.
      do {

         // Lire un message et l'afficher.
         try {
            message = ( String ) entree.readObject();
            zoneAffichage.append( "\n" + message );
            zoneAffichage.setCaretPosition(
               zoneAffichage.getText().length() );
         }

         // Capturer les problèmes de lecture à partir du serveur.
         catch ( ClassNotFoundException classNotFoundException ) {
            zoneAffichage.append( "\nObjet reçu de type inconnu" );
         }

      } while ( !message.equals( "SERVEUR>>> TERMINER" ) );

   }  // fin méthode traiterConnexion

   // Clore les flux et le socket.
   private void fermerConnexion() throws IOException
   {
      zoneAffichage.append( "\nClôture de la connexion." );
      sortie.close();
      entree.close();
      client.close();
   }

   // Envoyer un message au serveur.
   private void envoyerDonnees( String message ) {
      // Envoyer un objet au serveur.
      try {
         sortie.writeObject( "CLIENT>>> " + message );
         sortie.flush();
         zoneAffichage.append( "\nCLIENT>>> " + message );
      }

      // Traiter les problèmes à l'envoi d'objet.
      catch ( IOException ioException ) {
         zoneAffichage.append( "\nErreur à l'écriture d'un objet" );
      }
   }

   // Exécuter l'application.
   public static void main( String args[] ) {
      Client application;

      if ( args.length == 0 )
         application = new Client( "127.0.0.1" );
      else
         application = new Client( args[ 0 ] );

      application.setDefaultCloseOperation(
         JFrame.EXIT_ON_CLOSE );

      application.lancerClient();
   }

}  // fin classe Client


/******************************************************************************
 * (C) Copyright 2002 par Deitel & Associates, Inc. et Prentice Hall          *
 * Tous droits réservés.                                                      *
 *                                                                            *
 * RENONCIATION: Les auteurs et l'éditeur de cet ouvrage ont fait tous        *
 * les efforts pour préparer ce livre et les programmes qu'il contient,       *
 * y compris dans l'élaboration, la recherche et les contrôles sur l'effica-  *
 * cité des théories et programmes. Les auteurs et l'éditeur n'offrent        *
 * aucune garantie de quelque ordre que ce soit, expresse ou implicite,       *
 * pour ce qui concerne ces programmes ni la documentation présentés          *
 * dans ce livre. L'auteur et l'éditeur ne pourront être tenus pour           *
 * responsables de tout dommage accessoire ou indirect, lié à ou causé        *
 * par la fourniture, la performance ou l'utilisation de ces programmes.      *
 *****************************************************************************/