EventReplayManager.java

package edu.stanford.hci.r3.events.replay;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;

import edu.stanford.hci.r3.PaperToolkit;
import edu.stanford.hci.r3.events.EventEngine;
import edu.stanford.hci.r3.events.PenEvent;
import edu.stanford.hci.r3.events.PenEvent.PenEventModifier;
import edu.stanford.hci.r3.pen.PenSample;
import edu.stanford.hci.r3.util.DebugUtils;
import edu.stanford.hci.r3.util.files.FileUtils;

public class EventReplayManager {

        public static final String[] FILE_EXTENSION = new String[] { "eventData" };

        private static final String SEPARATOR = "\t";

        private EventEngine eventEngine;

        private ArrayList<PenEvent> loadedEvents = new ArrayList<PenEvent>();

        private PrintWriter output;

        private File outputFile;

        private boolean playEventsInRealTime = true;

        public EventReplayManager(EventEngine engine) {
                eventEngine = engine;
        }

        public void clearLoadedEvents() {
                loadedEvents = new ArrayList<PenEvent>();
        }

        public PenEvent createEventFromString(String eventString) {
                // DebugUtils.println(eventString);
                final String[] fields = eventString.split(SEPARATOR);
                final PenEventModifier modifier = PenEventModifier.valueOf(fields[0]);
                final String penName = fields[2];
                final int penID = Integer.parseInt(fields[1]);
                final long time = Long.parseLong(fields[3]);
                final double x = Double.parseDouble(fields[4]);
                final double y = Double.parseDouble(fields[5]);
                final long ts = Long.parseLong(fields[6]);
                final int f = Integer.parseInt(fields[7]);

                final PenEvent event = new PenEvent(penID, penName, time, new PenSample(x, y, f, ts));
                event.setModifier(modifier);
                return event;
        }

        private String createStringFromEvent(PenEvent event) {
                final PenSample sample = event.getOriginalSample();
                return event.getType() + SEPARATOR + event.getPenID() + SEPARATOR + event.getPenName()
                                + SEPARATOR + event.getTimestamp() + SEPARATOR + sample.getX() + SEPARATOR
                                + sample.getY() + SEPARATOR + sample.getTimestamp() + SEPARATOR + sample.getForce();
        }

        private File getEventStoragePath() {
                return new File(PaperToolkit.getToolkitRootPath(), "eventData/");
        }

        private PrintWriter getOutput() {
                if (output == null) {
                        try {
                                outputFile = new File(getEventStoragePath(), FileUtils
                                                .getCurrentTimeForUseInASortableFileName()
                                                + ".eventData");
                                output = new PrintWriter(new FileOutputStream(outputFile), true /* autoflush */);
                        } catch (FileNotFoundException e) {
                                e.printStackTrace();
                        }
                }
                return output;
        }

        public void loadEventDataFrom(File eventDataFile) {
                BufferedReader br;
                try {
                        br = new BufferedReader(new FileReader(eventDataFile));
                        String inputLine = null;
                        while ((inputLine = br.readLine()) != null) {
                                PenEvent event = createEventFromString(inputLine);
                                loadedEvents.add(event);
                        }
                        DebugUtils.println("Loaded " + loadedEvents.size() + " events.");
                        br.close();
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                }

        }

        public void loadMostRecentEventData() {
                final List<File> eventFiles = FileUtils.listVisibleFiles(getEventStoragePath(),
                                FILE_EXTENSION);
                if (eventFiles.size() > 0) {
                        final File mostRecentFile = eventFiles.get(eventFiles.size() - 1);
                        DebugUtils.println(mostRecentFile);
                        loadEventDataFrom(mostRecentFile);
                } else {
                        DebugUtils.println("No Event Data Files Found in " + getEventStoragePath());
                }
        }

        public void replay(final List<PenEvent> events) {
                new Thread(new Runnable() {
                        public void run() {
                                long lastTimeStamp = 0;
                                for (PenEvent event : events) {
                                        if (playEventsInRealTime && lastTimeStamp != 0) {
                                                try {
                                                        // pause some amount, to replicate realtime...
                                                        long diff = event.getTimestamp() - lastTimeStamp;
                                                        if (diff > 0) {
                                                                // DebugUtils.println("Sleeping for " + diff + " ms between
                                                                // events.");
                                                                Thread.sleep(diff);
                                                        }
                                                } catch (InterruptedException e) {
                                                        e.printStackTrace();
                                                }

                                        }

                                        // assume here that all PenEvent objects have their flags set correctly
                                        if (event.isTypePenUp()) {
                                                eventEngine.handlePenUpEvent(event);
                                        } else {
                                                eventEngine.handlePenEvent(event);
                                        }

                                        lastTimeStamp = event.getTimestamp();
                                }
                                DebugUtils.println("Done. Replayed " + events.size() + " Events");
                        }
                }).start();
        }

        public void replayLoadedEvents() {
                replay(loadedEvents);
        }

        public void saveEvent(PenEvent event) {
                getOutput().println(createStringFromEvent(event));
        }
}

---