/** * Copyright 2001 Sun Microsystems, Inc. *  * See the file "license.terms" for information on usage and * redistribution of this file, and for a DISCLAIMER OF ALL  * WARRANTIES. */import com.sun.speech.freetts.util.Utilities;import java.io.BufferedReader;import java.io.DataOutputStream;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStream;import java.net.Socket;import java.net.SocketTimeoutException;/** * Implements a very simplified (and incomplete) version of the * Emacspeak speech server. * * See the Emacspeak protocol document at * http://emacspeak.sourceforge.net/info/html/TTS-Servers.html * for more information. */public abstract class EmacspeakProtocolHandler implements Runnable {    // network related variables    private Socket socket;    private BufferedReader reader;    private OutputStream writer;    // synthesizer related variables    protected static final String PARENS_STAR_REGEX = "[.]*\\[\\*\\][.]*";    private static final int NOT_HANDLED_COMMAND = 1;    private static final int LETTER_COMMAND = 2;    private static final int QUEUE_COMMAND = 3;    private static final int TTS_SAY_COMMAND = 4;    private static final int STOP_COMMAND = 5;    private static final int EXIT_COMMAND = 6;    private static final int RATE_COMMAND = 7;        private String lastQueuedCommand;    private String stopQuestionStart = "Active processes exist;";    private boolean debug = false;    /**     * Sometimes emacspeak will embed DECTalk escape sequences in the     * text.  These sequences are not meant to be spoken, and FreeTTS     * currently does not interpret them.  This simple flag provides     * a mechanism for FreeTTS to cut strings of the form "[...]"     * out of text to be spoken (DECTalk escape sequences are of the     * form "[...]").  Since this is a relatively heavy-handed thing     * to do, this feature is turned off by default.  To turn it on,     * add -DstripDECTalk=true to the command line.     */    private boolean stripDECTalk = false;    /**     * Sets the Socket to be used by this ProtocolHandler.     *     * @param socket the Socket to be used     */    public void setSocket(Socket socket) {	this.socket = socket;	if (socket != null) {	    try {		reader = new BufferedReader		    (new InputStreamReader(socket.getInputStream()));		writer = new DataOutputStream(socket.getOutputStream());                socket.setKeepAlive(true);                // socket.setSoTimeout(5000);	    } catch (IOException ioe) {		ioe.printStackTrace();		throw new Error();	    }	}    }    /**     * Returns the socket used.     *     * @return the socket used     */    public Socket getSocket() {        return socket;    }    /**     * Set to debug mode, which will print out debug messages.     *     * @param true if set to debug mode, false if set to non-debug mode.     */    public void setDebug(boolean debug) {        this.debug = debug;    }    /**     * Returns true if the given input string starts with the given     * starting and ending sequence.     *     * @param start the starting character sequence     * @param end the ending character sequence     *      * @return true if the input string matches the given Pattern;     *         false otherwise     */    private static boolean matches(String start, String end, String input) {	return (input.startsWith(start) && input.endsWith(end));    }    /**     * Returns the type of the given command.     *     * @param command the command from emacspeak     *     * @return the command type     */    private static int getCommandType(String command) {	int type = NOT_HANDLED_COMMAND;        if (command.startsWith("l ")) {            type = LETTER_COMMAND;        } else if (command.startsWith("q ")) {            type = QUEUE_COMMAND;        } else if (command.startsWith("tts_say ")) {            type = TTS_SAY_COMMAND;        } else if (command.startsWith("tts_set_speech_rate ")) {            type = RATE_COMMAND;        } else if (command.equals("s")) {            type = STOP_COMMAND;        } else if (command.equals("exit")) {            type = EXIT_COMMAND;        }	return type;    }        /**     * Returns the text of the given input that is within curly     * brackets.  If there are no curly brackets (allowed in the     * Emacspeak protocol if the text has no spaces), then it     * just returns the text after the first space.     *     * @param input the input text     *     * @return text within curly brackets     */    public static String textInCurlyBrackets(String input) {	String result = "";	if (input.length() > 0) {	    int first = input.indexOf('{');            if (first == -1) {                first = input.indexOf(' ');            }	    int last = input.lastIndexOf('}');            if (last == -1) {                last = input.length();            }	    if (first != -1 && last != -1 &&		first < last) {		result = input.substring(first+1, last);	    }	}	return result.trim();    }    /**     * Strips DECTalk commands from the input text.  The DECTalk     * commands are anything inside "[" and "]".     */    public String stripDECTalkCommands(String content) {        int startPos = content.indexOf('[');        while (startPos != -1) {            int endPos = content.indexOf(']');            if (endPos != -1) {                if (startPos == 0) {                    if (endPos == (content.length() - 1)) {                        content = "";                    } else {                        content = content.substring(endPos + 1);                    }                } else {                    if (endPos == (content.length() - 1)) {                        content = content.substring(0, startPos);                    } else {                        String firstPart = content.substring(0, startPos);                        String secondPart = content.substring(endPos + 1);                        content = firstPart + " " + secondPart;                    }                }                startPos = content.indexOf('[');            } else {                break;            }        }        return content.trim();    }        /**     * Speaks the given input text.     *     * @param input the input text to speak.     */    public abstract void speak(String input);    /**     * Removes all the queued text.     */    public abstract void cancelAll();    /**     * Sets the speaking rate.     *     * @param wpm the new speaking rate (words per minute)     */    public abstract void setRate(float wpm);    /**     * Implements the run() method of Runnable     */    public synchronized void run() {        try {            String command = "";            stripDECTalk = Utilities.getBoolean("stripDECTalk");            while (isSocketLive()) {                command = reader.readLine();                if (command != null) {                    command = command.trim();                    debugPrintln("IN   : " + command);                    int commandType = getCommandType(command);                    if (commandType == EXIT_COMMAND) {                        socket.close();                        notifyAll();                    } else if (commandType == STOP_COMMAND) {                        cancelAll();                    } else if (commandType == RATE_COMMAND) {                        try {                            setRate(Float.parseFloat(                                        textInCurlyBrackets(command)));                        } catch (NumberFormatException e) {                            // ignore and do nothing                        }                    } else if (commandType != NOT_HANDLED_COMMAND) {                        String content = textInCurlyBrackets(command);                        if (stripDECTalk) {                            content = stripDECTalkCommands(content);                        }                        if (content.length() > 0) {                            speak(content);                        }                        // detect if emacspeak is trying to quit                        detectQuitting(commandType, content);                    } else {                        debugPrintln("SPEAK:");                    }                }            }        } catch (IOException ioe) {            ioe.printStackTrace();        } finally {            debugPrintln("EmacspeakProtocolHandler: thread terminated");        }    }    /**     * Returns true if the Socket is still alive.     *     * @return true if the Socket is still alive     */    private boolean isSocketLive() {        return (socket.isBound() &&                !socket.isClosed() && socket.isConnected() &&                !socket.isInputShutdown() && !socket.isOutputShutdown());    }    /**     * Read a line of text. A line is considered to be terminated      * by any one of a line feed ('\n'), a carriage return ('\r'),     * or a carriage return followed immediately by a linefeed.      *     * @return A String containing the contents of the line,      * not including any line-termination     * characters, or null if the end of the stream has been reached     *     * @throws IOException if an I/O error occurs     */    private String readLine() throws IOException {        String command = null;        boolean repeat = false;        do {            try {                command = reader.readLine();                repeat = false;            } catch (SocketTimeoutException ste) {                System.out.println("timed out");                /*                writer.write(-1);                writer.flush();                */                repeat = isSocketLive();            }        } while (repeat);             return command;    }        /**     * Detects and handles a possible emacspeak quitting sequence      * of commands, by looking at the given command type and content.     * If a quitting sequence is detected, it will close the socket.     * Note that this is not the best way to trap a quitting sequence,     * but I can't find another way to trap it. This method will     * do a socket.notifyAll() to tell objects waiting on the socket     * that it has been closed.      *     * @param commandType the command type     * @param content the contents of the command     */    private synchronized void detectQuitting(int commandType, String content)        throws IOException {        if (commandType == QUEUE_COMMAND) {            lastQueuedCommand = content;        } else if (commandType == TTS_SAY_COMMAND) {            if (content.equals("no")) {                lastQueuedCommand = "";            } else if (content.equals("yes") &&                       lastQueuedCommand.startsWith(stopQuestionStart)) {                socket.close();                notifyAll();            }        }    }    /**     * Prints the given message if the <code>debug</code> System property     * is set to <code>true</code>.     *     * @param message the message to print     */     public void debugPrintln(String message) {	if (debug) {	    System.out.println(message);	}    }}