HandwritingRecognitionService.java

package edu.stanford.hci.r3.pen.handwriting;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;

import edu.stanford.hci.r3.PaperToolkit;
import edu.stanford.hci.r3.config.Constants;
import edu.stanford.hci.r3.util.DebugUtils;
import edu.stanford.hci.r3.util.files.FileUtils;

public class HandwritingRecognitionService {

        private static final int HWREC_PORT = Constants.Ports.HANDWRITING_RECOGNITION;

        private static final String HWREC_SERVER = "localhost";

        private static HandwritingRecognitionService instance;

        private static final String HW_REC_SERVER_EXE = "HandwritingRecognition.exe";

        private static final String REL_PATH_TO_HWREC_SERVER = "handwritingRec/HWRecServer/bin/Release/";

        public synchronized static HandwritingRecognitionService getInstance() {
                if (instance == null) {
                        instance = new HandwritingRecognitionService();
                }
                return instance;
        }

        private boolean clientInitialized;

        private BufferedReader clientReader;

        private Socket clientSocket;

        private PrintWriter clientWriter;

        private boolean serverStarted;

        private HandwritingRecognitionService() {
                initializeServer();
                connectToServer();

                // Exit the Server upon shutdown...
                Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
                        public void run() {
                                HandwritingRecognitionService.getInstance().exitServer();
                        }
                }));
        }

        private synchronized void connectToServer() {
                if (clientInitialized) {
                        return;
                }

                while (!serverStarted) {
                        try {
                                DebugUtils.println("Waiting for the server to start up...");
                                wait();
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                }

                try {
                        clientSocket = new Socket(HWREC_SERVER, HWREC_PORT);
                        clientWriter = new PrintWriter(new BufferedWriter(
                                        new OutputStreamWriter(clientSocket.getOutputStream())));
                        clientReader = new BufferedReader(new InputStreamReader(
                                        clientSocket.getInputStream()));
                        clientInitialized = true;
                } catch (UnknownHostException e) {
                        DebugUtils.println("Unknown Host: " + e.getLocalizedMessage());
                        clientInitialized = false;
                } catch (IOException e) {
                        DebugUtils.println("IOException: " + e.getLocalizedMessage());
                        clientInitialized = false;
                }
        }

        private void disconnectClient() {
                try {
                        clientSocket.close();
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }

        public void exitServer() {
                clientWriter.println("[[quitserver]]");
                clientWriter.flush();
                disconnectClient();
        }

        public List<String> getAlternatives() {
                clientWriter.println("[[topten]]");
                clientWriter.flush();
                String line = null;
                final List<String> alternatives = new ArrayList<String>();
                try {
                        while ((line = clientReader.readLine()) != null) {
                                if (line.equals("[[endofalternatives]]")) {
                                        break;
                                }
                                alternatives.add(line);
                        }
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return alternatives;
        }

        private void initializeServer() {

                final Object mutex = this;

                // start a thread to start the server
                new Thread(new Runnable() {
                        public void run() {
                                // off of the PaperToolkit directory...
                                // handwritingRec\bin\HandwritingRecognition.exe
                                final File hwrecPath = new File(PaperToolkit
                                                .getToolkitRootPath(), REL_PATH_TO_HWREC_SERVER);
                                final File hwrecExe = new File(hwrecPath, HW_REC_SERVER_EXE);
                                final ProcessBuilder builder = new ProcessBuilder(hwrecExe
                                                .getPath());
                                builder.directory(hwrecPath);
                                try {
                                        final Process process = builder.start();

                                        DebugUtils.println(builder.directory());

                                        final InputStream inputStream = process.getInputStream();
                                        final BufferedReader br = new BufferedReader(
                                                        new InputStreamReader(inputStream));
                                        String line;
                                        // trap the console output
                                        while ((line = br.readLine()) != null) {
                                                System.out.println("Handwriting Server: " + line);
                                                synchronized (mutex) {
                                                        if (line.contains("[[serverstarted]]")) {
                                                                serverStarted = true;
                                                                mutex.notifyAll();
                                                        }
                                                }
                                        }
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                        }

                }).start();
        }

        public String recognizeHandwriting(File xmlFile) {
                return recognizeHandwriting(FileUtils.readFileIntoStringBuffer(xmlFile,
                                false).toString());
        }

        public String recognizeHandwriting(String xml) {
                clientWriter.println(xml);
                clientWriter.flush();
                try {
                        final String returnVal = clientReader.readLine();
                        return returnVal;
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return "";
        }
}

---