Colony

/*

*        ColonetServerInterface.java

*        Gregory Tress

*/

import java.net.*;

import java.io.*;

import javax.swing.JOptionPane;

import javax.swing.JTextArea;

/**

* The Colonet server interface class. This class handles direct communication with the Colonet server. The general

* contract is that this class will encapsulate the process of sending commands and requests to the server and 

* receiving responses. This class should provide methods to send specific commands and requests so that the 

* Colonet can easily communicate with the server. When data is received from the server, the ColonetServerInterface 

* decides how to handle it and in many cases this means simply passing it to the Colonet. 

* <p>

* The motivation is that any number of Colonet-type classes could be designed for different purposes if needed, with

* this class being used by each one for communication. 

* For instance, if an application is designed which only monitors sensor data, or that only has access to

* the task queue, etc., the application could easily plug in to this interface.

* The Colonet should generally not contain communication-specific code or Strings of command and request data. 

* If additional commands and requests are needed for permanent implementation, it is suggested that convenience

* classes be created in the ColonetServerInterface and called from the Colonet.

*

* @author Gregory Tress 

*/

public class ColonetServerInterface 

{

        /* STATIC FIELDS

         * Eugene Marinelli, Fan

         * 10/27/06

         *

         * Colonet Definitions - common definitions and structs used in all colonet 

         * applications

        Old packet structure:

    COMMAND PACKET STRUCTURE

        1:  SEND_TO_ROBOT

        2:  # of robot, or GLOBAL_DEST

        3:  COLONET_COMMMAND

        4:  message code (i.e. ORB_SET)

        5:  any data, as many that fit in the packet

        REQUEST PACKET STRUCTURE

        1:  REQUEST_FROM_SERVER

        2:  # of robot

        3:  COLONET_REQUEST

        4:  ???

  9/12/07 New server interface structure

    Client will no longer send full robot packets to the server.

    Commands will be defined as necessary.

        */

        //General Colonet Interface

        public static final String SEND_TO_ROBOT = "0";

        public static final String REQUEST_FROM_SERVER = "1";

        public static final String RESPONSE_TO_CLIENT_REQUEST = "2";

        public static final String REQUEST_BOM_MATRIX = "144";

        public static final String REQUEST_XBEE_IDS = "145";

        public static final String COLONET_COMMAND = "13"; //0x0D

        public static final String COLONET_REQUEST = "14"; //0x0E

        public static final String CORONET_RESPONSE = "15"; //0x0F

        public static final String GLOBAL_DEST = "200";

        public static final String CLIENT_REQUEST_ROBOT_POSITIONS = "86";

        public static final String CLIENT_ASSIGN_ROBOT_ID = "87";

        public static final String MOVE_TO_ABSOLUTE_POSITION = "83"; //0x53

        //Queue instructions

        public static final String COLONET_QUEUE = "100";

        public static final String QUEUE_UPDATE = "101"; 

        public static final String QUEUE_ADD = "102";

        public static final String QUEUE_REMOVE = "103";

        public static final String QUEUE_REORDER = "104";

        //Use BATTERY to request battery level

        public static final String BATTERY = "56"; //0x38

        //MOTORS

        public static final String MOTORS_INIT = "23"; //0x17

        public static final String MOTOR1_SET = "24"; //0x18

        public static final String MOTOR2_SET = "25"; //0x19

        public static final String MOTORS_OFF = "26"; //0x1A

        public static final String MOVE = "27"; //0x1B

        public static final String MOVE_AVOID = "28"; //0x1C

        //BUZZER

        public static final String BUZZER_INIT = "0"; //0x00

        public static final String BUZZER_SET_VAL = "1"; //0x01

        public static final String BUZZER_SET_FREQ = "2"; //0x02

        public static final String BUZZER_CHIRP = "3"; //0x03

        public static final String BUZZER_OFF = "4"; //0x04

        //ORB

        public static final String ORB_INIT = "12"; //0x0C

        public static final String ORB_SET = "13"; //0x0D

        public static final String ORB_SET_COLOR = "14"; //0x0E

        public static final String ORB_DISABLE = "15"; //0x0F

        public static final String ORB_ENABLE = "16"; //0x10

        public static final String ORB_SET_DIO = "17"; //0x11

        public static final String LED_INIT = "18"; //0x12

        public static final String LED_USER = "19"; //0x13

        public static final String ORB_SET_NUM_NS = "20"; //0x14

        public static final String ORB_SET_NUM = "21"; //0x15

        public static final String ORB_SEND = "22"; //0x16

        Colonet colonet;  //save reference to the entire applet locally

        Socket socket;

        OutputStreamWriter out;

        BufferedReader reader;

        DataListener dataListener;

        JTextArea log, txtMatrix;

        /*

        *        FUNCTION IMPLEMENTATIONS

        */

        /**

        * Constructs a new ColonetServerInterface. When constructing a ColonetServerInterface, a valid Colonet object

        * reference must be provided to ensure that data is routed correctly. 

        *

        * @param colonet The Colonet object to save locally. This reference cannot be changed once the 

        *                ColonetSreverInterface has been contsructed.

        * @throws NullPointerException if colonet is null

        *

        */

        public ColonetServerInterface (Colonet colonet) {

                this.colonet = colonet;

                this.log = colonet.getLog();

                this.txtMatrix = colonet.getMatrixInput();

                dataListener = new DataListener();

        }

        public Socket getSocket () {

                return socket;

        }

        public OutputStreamWriter getOutputStreamWriter () {

                return out;

        }

        public BufferedReader getBufferedReader () {

                return reader;

        }

        public boolean isReady () {

                if (socket == null || out == null || reader == null)

                        return false;

                if (!socket.isConnected() || socket.isClosed() || socket.isInputShutdown() || socket.isOutputShutdown())

                        return false;

                return true;

        }

        public boolean isInputReady () {

                try {

                        if (reader.ready()) return true;

                } catch (Exception e) {

                        return false;

                }

                return false;

        }

        public String getLine () throws IOException {

                return reader.readLine();

        }

        /**

         * Create socket connection to Colonet server.

         * If successful, start thread for listening for incoming data.

         */

        public void connect (String strHost, String strPort) {

                //make sure hostname and port are valid

                if (strHost.equals("") || strPort.equals("")) {

                        err("Please enter a hostname and port.");

                        return;

                }

                int port = 0;

                try {

                        port = Integer.parseInt(strPort);

                } catch (Exception e) {

                        err("Invalid port");

                        return;

                }

                //make sure we aren't already connected.

                if (socket != null && socket.isConnected()) {

                        return;

                }

                try {

                        socket = new Socket(strHost, port);

                        socket.setKeepAlive(true);

                } catch (UnknownHostException e) {

                        log.append("Unknown host exception.\n");

                        err("Unknown Host Exception");

                        return;

                } catch (IOException e) {

                        log.append("IO Exception.\n");

                        err("Could not create socket to " + strHost + ".\n" + e);

                        return;

                } catch (java.security.AccessControlException e) {

                        log.append("Access Control Exception.\n");

                        err("Permission denied by java.security.AccessControlException.\n\n"

                                +"You may only connect to the server from which this applet was loaded.");

                        return;

                }

                if (socket == null || !socket.isConnected()) {

                        log.append("Connection is not ready. Try connecting again.\n");

                        return;

                }

                try {

                        out = new OutputStreamWriter(socket.getOutputStream());

                        reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));

                } catch (IOException e) {

                        warn("Could not get transfer streams from socket connection.");

                }

                dataListener.start();

        }

        public void disconnect () {

        }

        /*

        *        sendString - only this method should actually write data to the output stream

        */

        private void sendString (String s) {

                //make sure we can send

                if (!this.isReady()) {

                        log.append("Could not send data.\n");

                        return;

                }

                //send packet

                try {

                        Thread.sleep(50);  //pause to be safe

                        out.write(s);

                        out.flush();

                        //log.append("Sent: " + s + "\n");

                } catch (IOException e) {

                        log.setText("Could not send data.\n");

                } catch (InterruptedException e) {

                        log.setText("Thread InterruptedException in sendData\n");

                }

        }

        /**

        * General send-to-server method. This method is used by other command methods, which are usually convenience

        * methods that simply specify arguments to this method. A command consists of a String which holds integers 

        * separated by spaces. This method should not be used directly unless you know the format of the particular 

        * command you are sending. If implementing a particular command for permanent use, it is recommended that 

        * you create a new wrapper method specific to that command in the ColonetServerInterface file.

        *

        * Note that no checking is performed in this method to ensure the correct formatting of the String arguments.

        * If malformed commands or robot numbers are specified, the behavior of the request at the server will be

        * undefined and could result in server failure. 

        *

        * @param s The command String in its correct format. The format of a command String is ultimately specified

        * by the Colonet server application and may change. 

        * @param robotNumber The number of the robot that is the subject of the command, if any. The robot number 

        * is specified as a single integer in a String. If the command does not have a single robot subject, this 

        * argument can be null or an empty String, whichever is convenient. 

        */

        public void sendData (String s, String robotNumber) { 

                //create packet

                String packet = "";

                packet += ColonetServerInterface.SEND_TO_ROBOT;

                if (robotNumber != null)

                        packet += " " + 7;  //robotNumber;

                packet += " " + ColonetServerInterface.COLONET_COMMAND;

                packet += " " + s;  //add  the command code here

                packet += "\n";

                sendString(packet);

                txtMatrix.append("S:" + packet);

        }

        /**

        * General request-from-server method. This method is used by other request methods, which are usually convenience

        * methods that simply specify arguments to this method. A request consists of a String which holds integers 

        * separated by spaces. This method should not be used directly unless you know the format of the particular 

        * request you are making. If implementing a particular request, it is recommended that you create a new method

        * specific to that request in the ColonetServerInterface file.

        *

        */

        private void sendRequest (String s, String robotNumber) {

                //create packet

                String packet = "";

                packet += ColonetServerInterface.REQUEST_FROM_SERVER;

                packet += " " + robotNumber;

                packet += " " + s;  //add  the command code here

                packet += "\n";

                sendString(packet);

        }

        /** 

        * Sends a request to the server to report the entire BOM sensor matrix. The server will reply at its convenience. 

        * No guarantee is made (end-to-end or otherwise) that the server will respond in a timely manner or at all

        * to any individual request.

        */

        public void sendSensorDataRequest () {

                sendRequest(ColonetServerInterface.REQUEST_BOM_MATRIX, "");

        }

        /**

        * Sends a request to the server to report a list of XBee IDs. The server will reply at its convenience. 

        * The purpose of having this list is to ensure that robots are properly identified for control purposes.

        * This keeps robot identification consistent between sessions and prevents arbitrary assignment. 

        * No guarantee is made (end-to-end or otherwise) that the server will respond in a timely manner or at all

        * to any individual request.

        *

        * @see Colonet#parseXBeeIDs(String)

        */

        public void sendXBeeIDRequest () {

                sendRequest(ColonetServerInterface.REQUEST_XBEE_IDS, "");

        }

        /**

        * Sends a battery request for a specific robot to the server. The server will reply at its convenience. 

        * Behavior is undefined if an invalid robot number is specified. The server will probably not respond in 

        * this case.

        * No guarantee is made (end-to-end or otherwise) that the server will respond in a timely manner or at all

        * to any individual request.

        *

        * @param robotNum The number of the robot for which we are requesting the battery. Note that this value

        * is sent as-is to the server. No mapping to or from XBee IDs is performed. The contract for this is

        * currently undefined.

        * @see Colonet#parseBattery(String)

        */

        public void sendBatteryRequest (int robotNum) {

                //create packet

                String packet = "";

                packet += ColonetServerInterface.SEND_TO_ROBOT;

                packet += " " + robotNum;

                packet += " " + ColonetServerInterface.COLONET_REQUEST;

                packet += " " + ColonetServerInterface.BATTERY;  //add  the command code here

                packet += "\n";

                sendString(packet);

        }

        /**

        * Requests a list of all robot positions and correspondind robot IDs.

        */

        public void sendPositionRequest () {

                sendRequest(ColonetServerInterface.CLIENT_REQUEST_ROBOT_POSITIONS, "");

        }

        /**

        * Send a robot ID assignment update to store on the server.

        */

        public void sendIDAssignment (int oldID, int newID) {

                String packet = "";

                packet += ColonetServerInterface.REQUEST_FROM_SERVER;

                packet += " " + oldID + " " + newID;

                packet += "\n";

                sendString(packet);

                txtMatrix.append("ID " + oldID + " => " + newID + "\n");

        }

        /** 

        * Order a robot to move to an absolute coordinate point.

        */

        public void sendAbsoluteMove (int id, int x, int y) {

            sendData(MOVE_TO_ABSOLUTE_POSITION + " " + x + " " + y, "" + id);

        }

        /*

        *        Queue management

        */

        private void sendQueueInstruction (String inst) {

                String packet = "";

                packet += ColonetServerInterface.COLONET_QUEUE;

                packet += " " + inst;

                packet += "\n";

                sendString(packet);

        }

        /**

        * Notifies the Colonet server to add a task to the current task queue. The Colonet server holds the canonical 

        * task queue. Any applet can send tasks to add to the queue. Local copies of the queue in the applet are for

        * display purposes only, and are not authoritative when adding tasks. All clients send additions asynchronously,

        * and as a result no guarantee is made that a task will be added in the specificed location in the queue or at 

        * all. If an invalid position is specified, the task will probably not be added to the queue and may cause

        * server failure. Due to the asynchronous nature of the queue, we cannot easily account for concurrent

        * modification failures on the client side.

        *

        * @param pos The position in the queue at which we would like the task to be placed. Note that this is not 

        * guaranteed. Invalid positions may cause the task to be discarded at the server.

        * @param data The String containing the command code(s) for the task and any arguments necessary to fully 

        * define the behavior of the task. This format is currently not specified. In the future, the canonical format

        * of the data String will ultimately be defined by the Colonet server.

        * @param description A String that contains a description of the task. This will be the message displayed to

        * the user when information about the task is requested. 

        */

        public void sendQueueAdd (int pos, String data, String description) {

                String packet = "";

                packet += ColonetServerInterface.QUEUE_ADD;

                packet += " " + pos;

                packet += " " + data;

                packet += " [" + description + "]";

                packet += "\n";

                sendQueueInstruction(packet);

        }

        /**

        * Notifies the Colonet server to remove a task from the current task queue. The Colonet server holds the canonical 

        * task queue. Any applet can remove a task from the queue. Local copies of the queue in the applet are for

        * display purposes only, and are not authoritative when removing tasks. All clients remove tasks asynchronously,

        * and as a result no guarantee is made that the correct task will actually be removed. 

        * If an invalid position is specified, the state of the queue is undefined and server failure may result.

        * Due to the asynchronous nature of the queue, we cannot easily account for concurrent

        * modification failures on the client side.

        *

        * @param pos The position in the queue at which we would like the task to be removed. Note that this is not 

        * guaranteed. Invalid positions may result in a corrupted queue.

        */

        public void sendQueueRemove (int pos) {

                String packet = "";

                packet += ColonetServerInterface.QUEUE_REMOVE;

                packet += " " + pos;

                packet += "\n";

                sendQueueInstruction(packet);

        }

        /**

        * Notifies the Colonet server to reorder tasks in the current task queue. The Colonet server holds the canonical 

        * task queue. Any applet can reorder tasks in the queue. Local copies of the queue in the applet are for

        * display purposes only, and are not authoritative when reordering tasks. All clients reorder tasks asynchronously,

        * and as a result no guarantee is made that the correct tasks will actually be reordered. 

        * If an invalid position is specified, the state of the queue is undefined and server failure may result.

        * Due to the asynchronous nature of the queue, we cannot easily account for concurrent

        * modification failures on the client side.

        *

        * @param pos1 The queue position of a task which we would like to reorder.

        * @param pos2 The queue position of a task which we would like to reorder.

        */

        public void sendQueueReorder (int pos1, int pos2) {

                String packet = "";

                packet += ColonetServerInterface.QUEUE_REORDER;

                packet += " " + pos1;

                packet += " " + pos2;

                packet += "\n";

                sendQueueInstruction(packet);

        }

        public void sendQueueUpdate () {

                sendQueueInstruction(ColonetServerInterface.QUEUE_UPDATE);

        }

        /**

         * Display informational message box on the screen. Used for casual communicaton to the user.

         * @param text Text to display

         */

        public void msg (String text) {

                JOptionPane.showMessageDialog(colonet, text, "Colonet", JOptionPane.INFORMATION_MESSAGE);

        }

        /**

         * Display warning message box on the screen. Used for minor alerts or exceptions.

         * @param text Text to display

         */

        public void warn (String text) {

                JOptionPane.showMessageDialog(colonet, text, "Colonet", JOptionPane.WARNING_MESSAGE);

        }

        /**

         * Display error message box on the screen. Used for major errors or exceptions in the program.

         * @param text Text to display

         */

        public void err (String text) {

                JOptionPane.showMessageDialog(colonet, text, "Colonet", JOptionPane.ERROR_MESSAGE);

        }

        /*

        *        DataListener thread.

        *

        */

        class DataListener extends Thread {

                final int DATALISTENER_DELAY = 222;

                public DataListener () {

                        super("Colonet DataListener");

                }

                public void run () {

                        String line;

                        while (true) { 

                                try {

                                        line = reader.readLine();

                                        if (line == null)

                                            throw new IOException();

                                        parseData(line);

                                        Thread.sleep(DATALISTENER_DELAY);

                                } catch (InterruptedException e) {

                                        return;

                                } catch (IOException e) {

                                disconnect();

                                    colonet.disconnect();

                                    return;

                                }

                        }

                }

                public void parseData (String line) {

                        // Sensor Matrix

                        if (line.startsWith(ColonetServerInterface.RESPONSE_TO_CLIENT_REQUEST + " " +

                                ColonetServerInterface.REQUEST_BOM_MATRIX))

                                colonet.parseMatrix(line);

                        // Task Queue

                        else if (line.startsWith(ColonetServerInterface.COLONET_QUEUE))

                                colonet.parseQueue(line);

                        // XBee IDs

                        else if (line.startsWith(ColonetServerInterface.RESPONSE_TO_CLIENT_REQUEST + " " +

                                ColonetServerInterface.REQUEST_XBEE_IDS))

                                colonet.parseXBeeIDs(line);

                        // Battery

                        else if (line.startsWith(ColonetServerInterface.RESPONSE_TO_CLIENT_REQUEST + " " +

                                ColonetServerInterface.BATTERY))

                                colonet.parseBattery(line);

                        // Robot Positions

                        else if (line.startsWith(ColonetServerInterface.RESPONSE_TO_CLIENT_REQUEST + " " +

                                ColonetServerInterface.CLIENT_REQUEST_ROBOT_POSITIONS))

                                colonet.parsePositions(line);

                        // Unknown type

                        else

                                txtMatrix.setText("Got unknown data: " + line + "\n");

                }

        }

}