Source code: org/incenter/ngbclient/objSocket.java

   
   package org.incenter.ngbclient;
   import org.incenter.ngbclient.*;
   import org.incenter.gb.*;
   
   // Imports
   import java.net.*;
   import java.io.*;
   import java.util.*;
  import java.util.zip.*;
  import java.lang.*;
  
  
  public class objSocket extends Observable implements Runnable
  {
      boolean loggedIn, reading, writing;
      Socket socket;
      ObjectInputStream inStream;
      ObjectOutputStream outStream;
      GZIPInputStream GZIPin;
      GZIPOutputStream GZIPout;
      InputStream in;
  
      public static final int SERVER = 0;
      public static final int CLIENT = 1;
  
      public boolean getReading() { return reading; }
      public boolean getWriting() { return writing; }
  
      game_remote game;
      public game_remote getGame() {return game;}
      public void setGame(game_remote  v) {this.game = v;}
  
      login login;
      public login getLogin() {return login;}
      public void setLogin(login  v) {this.login = v;}
      
      int raceId;
      public int getRaceId() {return raceId;}
      public void setRaceId(int  v) {this.raceId = v;}
      
      String racePass;
      public String getRacePass() {return racePass;}
      public void setRacePass(String  v) {this.racePass = v;}
      
      String govPass;
      public String getGovPass() {return govPass;}
      public void setGovPass(String  v) {this.govPass = v;}
      
      int mode;
      public int getMode() {return mode;}
      public void setMode(int  v) {this.mode = v;}
      
      Thread thread;
      public Thread getThread() {return thread;}
      public void setThread(Thread  v) {this.thread = v;}
      
      int status;
      public int getStatus() {return status;}
      public void setStatus(int  v) {this.status = v;}
      
      netPacket lastPacket;
      public netPacket getLastPacket() {return lastPacket;}
      public void setLastPacket(netPacket  v) {this.lastPacket = v;}
  
      // object cache
  
      Hashtable cache;
      public Hashtable getCache() {return cache;}
      public void setCache(Hashtable  v) {this.cache = v;}
      
      int port;
      public static final int DEFAULT_PORT = 2031;
  
      public objSocket() {
    port = DEFAULT_PORT;
    mode = CLIENT;
    socket = null;
    loggedIn = false;
      }
  
      public void connect(String host, int port) throws Exception {
        try {
      socket = new Socket(host, port);
      status = -1;
      try {
          outStream = new ObjectOutputStream(socket.getOutputStream());
          outStream.flush();
  
          in = socket.getInputStream();
          inStream = new ObjectInputStream(in);} 
      catch(InterruptedIOException e) {;}
  
      status = 0;
      lastPacket = null;
        } catch (Exception e) {
      socket = null;
      status = -1;
      throw new Exception("Object Socket Error:" + e);
       }
     }
 
     private void errorDlg(String s) {
 
     }
 
     public void run() {
   boolean rcvd = false;
   if(socket == null) {
       return;
   }
   try {
       while(isConnected()) {
     try {
         if(isReady()) {
       rcvd = receive();
       reading = false;
         }
         if(!rcvd)
       try {thread.sleep(1000);} catch(Exception e) {;}
         status = 0;
         rcvd = false;
     } catch(Exception e) {
         status = -1;
         break;
     }
       }
   } catch(Exception e) {
       status = -1;
   }
     }
 
     private boolean isReady() throws Exception {
   try {
       if(in.available() > 0)
     return true;
       else 
     return false;
   } catch(Exception e) {
       throw new Exception("isReady::" + e);
   }
     }
 
     public void sendCommand(String id, String txt) throws Exception {
   try {
       netPacket np = new netPacket(new cmdId(id),
            new objCommand(txt),
            netPacket.CLIENT);
       send(np);
   } catch(Exception e) { throw new Exception("Error sending command:" + e.getMessage()); }
     }
 
     public void send(netPacket np) throws Exception {
   try {
       writing = true;
       outStream.writeObject(np);
       outStream.flush();
       writing = false;
   } catch(Exception e) {
       throw new Exception("objSocket.send()::" + e);
   }
     }
     
     public boolean receive() throws Exception {
   try {
       if(!isConnected())
     throw new Exception("receive()::not connected");
   } catch(Exception e) {
       throw new Exception("objSocket.receive()::" + e);
   }
 
   try {
       reading = true;
       Object ob = inStream.readObject();
       if(!(ob instanceof netPacket)) {
     return false;
       }
       lastPacket = (netPacket)ob;
       if(loggedIn) {
     if(countObservers() > 0) {
         setChanged();
         notifyObservers(lastPacket);
     }
     lastPacket = null;
     return true;
       } else {
     // still waiting for the game object
     if(lastPacket.getObjects().size() == 1) {
         ob = lastPacket.getObjects().elementAt(0);
         if((ob instanceof game_remote)) {
       game = (game_remote)ob;
       netPacket np = new netPacket(new cmdId("Login"),
                  login,
                  netPacket.CLIENT);
       send(np);
       loggedIn = true;
       setChanged();
       notifyObservers("Waiting for login..");
       return true;
         }
     } else {
         return false;
     }
       }
       return true;
 
   } catch(Exception e) {
       lastPacket = null;
       throw new Exception("objSocket.receive()::" + e);
   }
     }
     
     public void closeConnections() throws Exception  {
   try {
       if(socket == null) return;
       socket.close();
       socket = null;
       setChanged();
       notifyObservers(new String("objConnectionClosed"));
   }
   catch (Exception e) {
       socket = null;
       status = -1;
       throw new Exception("objSocket.closeConnections()::" + e);
   }
     }
     
     public boolean isConnected() throws Exception {
   try {
       if(socket == null) {
     inStream = null;
     outStream = null;
     return false;
       }
       if(inStream == null || outStream == null) {
     throw new Exception("objSocket.isConnected():No streams");
       }
       return true;
   } catch(Exception e) {
       throw new Exception("objSocket.receive()::" + e);
   }
     }
 
     protected void finalize () {
   if (socket != null) {
       try {
     socket.close();
       }
       catch (Exception e) {
     status = -1;
       }
       socket = null;
   }
     }
 
 }