migration to gradle, splitted wiiusej, wiigee and itunescontroller into subprojects

java/mimis/.classpath

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src/main/java"/>
+	<classpathentry kind="src" path="src/main/resources"/>
+	<classpathentry exported="true" kind="src" path="/itunescontroller"/>
+	<classpathentry exported="true" kind="src" path="/wiigee"/>
+	<classpathentry exported="true" kind="src" path="/wiiusej"/>
+	<classpathentry exported="true" kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry exported="true" kind="con" path="org.springsource.ide.eclipse.gradle.classpathcontainer"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

java/mimis/.project

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>mimis</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.springsource.ide.eclipse.gradle.core.nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

java/mimis/build.gradle

@@ -0,0 +1,35 @@
+import java.util.jar.JarEntry;
+
+apply plugin: 'java'
+apply plugin: 'eclipse'
+apply plugin: 'cpp-lib'
+
+version = '0.1'
+
+sourceCompatibility = 1.6
+targetCompatibility = 1.6
+
+def mainClass = 'mimis.Main'
+
+repositories {
+	mavenCentral()
+}
+
+dependencies {
+	compile project(':itunescontroller')
+	compile project(':wiiusej')
+	compile project(':wiigee')
+
+	compile 'commons-collections:commons-collections:3.+'
+	compile 'commons-logging:commons-logging:1.+'
+	compile 'log4j:log4j:1.2.17'
+	compile 'com.melloware:jintellitype:1.3.7'
+	
+	compile fileTree(dir: 'lib', include: '*.jar')
+}
+
+jar {
+	manifest {
+		attributes 'Main-Class': mainClass
+	}
+}

java/mimis/build.xml

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<project default="jar" name="Build file for Project Mimis">
+	<!-- All -->
+	<target name="all" depends="javadoc, jar, launch4j"></target>
+	
+	<!-- Javadoc -->
+	<target name="javadoc">
+		<javadoc access="private" author="true" classpath="cfg;resource;lib/log4j-1.2.16.jar;lib/jxinput.jar;lib/commons-logging-1.1.1.jar;lib/jacob-1.15-M3.jar" destdir="doc" nodeprecated="false" nodeprecatedlist="false" noindex="false" nonavbar="false" notree="false" packagenames="mimis.exception.macro,mimis.device.network,wiiusej,mimis.application.itunes,mimis.exception.util,mimis.device.javainput,wiiusej.wiiusejevents,wiiusej.wiiusejevents.utils,mimis.util.swing,mimis.exception.worker,mimis.application.lirc,mimis.application.cmd.windows.winamp,wiiusej.values,mimis.exception.event,mimis.device.lirc.remote,mimis.device.panel,mimis.exception.device,mimis.exception.button,mimis.application.robot,mimis.application.lirc.ipod,mimis.exception.task.action,mimis.exception.application,wiiusej.wiiusejevents.wiiuseapievents,mimis.application.cmd.windows.gomplayer,mimis.application.mpc,org.wiigee.logic,mimis.device.lirc,mimis.sequence,mimis.manager,org.wiigee.util,mimis.event,mimis.application.cmd.windows.wmp,mimis.value,mimis.device.javainput.extreme3d,mimis.event.router,mimis.application.cmd,mimis.worker,org.wiigee.event,mimis.device.wiimote,mimis.device.wiimote.gesture.event,wiiusej.wiiusejevents.physicalevents,mimis.util.multiplexer,mimis,org.wiigee.control,mimis.exception.device.javainput,mimis.util,mimis.application.cmd.windows,com.dt.iTunesController,org.wiigee.device,mimis.application.vlc,mimis.device.wiimote.gesture,mimis.device.jintellitype,mimis.event.feedback,mimis.device,org.wiigee.filter,mimis.exception.application.windows,mimis.application,mimis.sequence.state,mimis.device.javainput.rumblepad,com.melloware.jintellitype,mimis.exception.event.router,mimis.exception.task,mimis.exception" source="1.6" sourcepath="src" splitindex="true" use="true" version="true" />
+	</target>
+
+	<!-- Jar -->
+	<target name="jar">
+		<property name="jar.dir" value="." />
+		<jar destfile="${jar.dir}/main.jar" filesetmanifest="mergewithoutmain">
+			<manifest>
+				<attribute name="Main-Class" value="mimis.Main" />
+				<attribute name="Class-Path" value="." />
+			</manifest>
+			<fileset dir="bin" />
+			<fileset dir="resource" />
+			<zipfileset excludes="META-INF/*.SF" src="lib/commons-logging-1.1.1.jar" />
+			<zipfileset excludes="META-INF/*.SF" src="lib/log4j-1.2.16.jar" />
+			<zipfileset excludes="META-INF/*.SF" src="lib/jacob-1.15-M3.jar" />
+			<zipfileset excludes="META-INF/*.SF" src="lib/jxinput.jar" />
+			<fileset dir="cfg" />
+		</jar>
+		<jar destfile="${jar.dir}/client.jar" filesetmanifest="mergewithoutmain">
+			<manifest>
+				<attribute name="Main-Class" value="mimis.Client" />
+				<attribute name="Class-Path" value="." />
+			</manifest>
+			<fileset dir="bin" />
+			<fileset dir="resource" />
+			<zipfileset excludes="META-INF/*.SF" src="lib/commons-logging-1.1.1.jar" />
+			<zipfileset excludes="META-INF/*.SF" src="lib/log4j-1.2.16.jar" />
+			<zipfileset excludes="META-INF/*.SF" src="lib/jacob-1.15-M3.jar" />
+			<zipfileset excludes="META-INF/*.SF" src="lib/jxinput.jar" />
+			<fileset dir="cfg" />
+		</jar>
+		<copy todir="${jar.dir}">
+			<fileset dir=".">
+				<include name="*.dll" />
+				<include name="*.exe" />
+			</fileset>
+		</copy>
+	</target>
+
+	<!-- Launch4j -->
+	<target name="launch4j" depends="jar">
+		<property name="launch4j.dir" location="C:\Program Files (x86)\Launch4j" />
+		<path id="launch4j">
+			<pathelement location="${launch4j.dir}/launch4j.jar" />
+			<pathelement location="${launch4j.dir}/lib/xstream.jar" />
+		</path>
+		<taskdef name="launch4j" classname="net.sf.launch4j.ant.Launch4jTask">
+			<classpath refid="launch4j" />
+		</taskdef>
+		<launch4j configFile="launch4j.xml" />
+		<delete file="launch4j.log" />
+	</target>
+</project>

java/mimis/launch4j.xml

@@ -0,0 +1,22 @@
+<launch4jConfig>
+  <dontWrapJar>false</dontWrapJar>
+  <headerType>gui</headerType>
+  <jar>main.jar</jar>
+  <outfile>mimis.exe</outfile>
+  <errTitle>Mimis</errTitle>
+  <cmdLine></cmdLine>
+  <chdir></chdir>
+  <priority>normal</priority>
+  <downloadUrl>http://java.com/download</downloadUrl>
+  <supportUrl></supportUrl>
+  <customProcName>true</customProcName>
+  <stayAlive>false</stayAlive>
+  <manifest></manifest>
+  <icon>resource\M.ico</icon>
+  <jre>
+    <path></path>
+    <minVersion>1.6.0</minVersion>
+    <maxVersion></maxVersion>
+    <jdkPreference>preferJre</jdkPreference>
+  </jre>
+</launch4jConfig>

java/mimis/src/main/java/mimis/Client.java

@@ -0,0 +1,25 @@
+package mimis;
+
+import mimis.exception.worker.ActivateException;
+import mimis.router.GlobalRouter;
+import mimis.util.swing.Dialog;
+
+public class Client extends Main {
+    public static final String IP = "127.0.0.1";
+    public static final int PORT = 6789;
+
+    public Client(String ip, int port) {
+        super();
+        router = new GlobalRouter(ip, port);
+    }
+
+    public void activate() throws ActivateException {
+        super.activate();
+    }
+
+    public static void main(String[] args) {
+        String ip = Dialog.question("Server IP:", IP);
+        int port = Integer.valueOf(Dialog.question("Server Port:", PORT));
+        new Client(ip, port).start();
+    }
+}

java/mimis/src/main/java/mimis/Gui.java

@@ -0,0 +1,98 @@
+package mimis;
+
+import java.awt.GridLayout;
+import java.awt.TextArea;
+import java.awt.event.WindowEvent;
+
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.WindowConstants;
+
+import mimis.exception.worker.ActivateException;
+import mimis.input.Feedback;
+import mimis.input.Input;
+import mimis.manager.ButtonManager;
+import mimis.util.Swing;
+import mimis.worker.Component;
+
+public class Gui extends Component {
+    public static final String ICON = "M.png";
+    public static final String TITLE = "MIMIS Manager";
+
+    protected JFrame frame;
+    protected Component component;
+    protected TextArea textArea;
+
+    public Gui(final Component component, ButtonManager... buttonManagerArray) {
+        frame = new JFrame(TITLE) {
+            protected static final long serialVersionUID = 1L;
+            protected void processWindowEvent(WindowEvent event) {
+                if (event.getID() == WindowEvent.WINDOW_CLOSING) {
+                    log.debug("Window closing");
+                    component.exit();
+                }
+            }
+        };
+        this.component = component;
+        frame.setIconImage(Swing.getImage(ICON));
+        createFrame(buttonManagerArray);
+    }
+
+    protected void activate() throws ActivateException {
+        listen(Feedback.class);
+        super.activate();
+    }
+
+    public void exit() {
+        super.exit();
+        frame.dispose();
+    }
+
+    protected void createFrame(ButtonManager... buttonManagerArray) {
+        frame.setLayout(new GridLayout(0, 1));
+        JPanel controlPanel = createControlPanel(buttonManagerArray);
+        frame.add(controlPanel);
+        JPanel feedbackPanel = createTextPanel();
+        frame.add(feedbackPanel);
+        frame.setResizable(false);
+        frame.setVisible(true);
+        frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+        frame.pack();
+    }
+
+    protected JPanel createControlPanel(ButtonManager... buttonManagerArray) {
+        JPanel controlPanel = new JPanel(new GridLayout(1, 0));
+        for (ButtonManager buttonManager  : buttonManagerArray) {
+            if (buttonManager.count() > 0) {
+                controlPanel.add(buttonManager.createPanel());
+            }
+        }
+        return controlPanel;
+    }
+
+    protected JPanel createTextPanel() {
+        JPanel textPanel = new JPanel();
+        textArea = new TextArea();
+        textArea.setEditable(false);
+        textPanel.add(textArea);
+        return textPanel;
+    }
+
+    public void input(Input input) {
+        if (input instanceof Feedback) {
+            writeLine(((Feedback) input).getText());
+        }
+    }
+
+    public void write(String string) {
+        textArea.append(string);
+    }
+
+    public void writeLine(String string) {
+        write(string + "\n");
+    }
+
+    public void clear() {
+        textArea.setText(null);
+    }
+}

java/mimis/src/main/java/mimis/Main.java

@@ -0,0 +1,102 @@
+package mimis;
+
+import java.util.ArrayList;
+import java.util.ServiceLoader;
+
+import javax.swing.UIManager;
+
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.input.Task;
+import mimis.manager.ButtonManager;
+import mimis.manager.CurrentButtonManager;
+import mimis.value.Action;
+import mimis.worker.Component;
+
+public class Main extends Mimis {
+    protected CurrentButtonManager applicationManager;
+    protected ButtonManager deviceManager;
+    protected Gui gui;
+
+    static {
+        try {
+            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+        } catch (Exception e) {}
+        
+    }
+
+    public static Component[] getApplications() {
+    	return  getComponents(mimis.application.Application.class);
+    }
+
+    public static Component[] getDevices() {
+    	return getComponents(mimis.device.Device.class);
+    }
+
+    public static Component[] getComponents(Class<?> clazz) {
+    	ArrayList<Component> componentList = new ArrayList<Component>();
+    	for (Object object : ServiceLoader.load(clazz)) {
+    		if (object instanceof Component) {
+    			componentList.add((Component) object);
+    		}
+    	}
+    	return componentList.toArray(new Component[]{});
+    }
+
+    public Main() {
+        super(getApplications());
+
+        /* Create gui from application and device managers */
+        applicationManager = new CurrentButtonManager(router, componentCycle, "Applications", currentArray);
+        deviceManager = new ButtonManager("Devices", initialize(false, getDevices()));
+        gui = new Gui(this, applicationManager, deviceManager);
+        manager.add(initialize(false, gui));
+    }
+
+    public void activate() throws ActivateException {
+        super.activate();
+        listen(Task.class);
+
+        /* Start managers */
+        applicationManager.start();
+        deviceManager.start();
+
+        /* Force display of current component when gui started */
+        gui.start();
+        while (!gui.active());
+        end(Action.CURRENT);
+    }
+
+    protected void deactivate() throws DeactivateException {
+        super.deactivate();
+
+        log.debug("Stop managers");
+        applicationManager.stop();
+        deviceManager.stop();
+    }
+
+    public void exit() {
+        super.exit();
+
+        log.debug("Exit managers");
+        applicationManager.exit();
+        deviceManager.exit();
+    }
+
+    public void end(Action action) {
+        super.end(action);
+        switch (action) {
+            case CURRENT:
+            case NEXT:
+            case PREVIOUS:
+                applicationManager.currentChanged();
+                break;
+			default:
+				break;
+        }
+    }
+
+    public static void main(String[] args) {
+        new Main().start(false);
+    }
+}

java/mimis/src/main/java/mimis/Mimis.java

@@ -0,0 +1,81 @@
+package mimis;
+
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.input.Feedback;
+import mimis.input.Task;
+import mimis.manager.Manager;
+import mimis.parser.Parser;
+import mimis.router.Router;
+import mimis.util.ArrayCycle;
+import mimis.value.Action;
+import mimis.value.Target;
+import mimis.worker.Component;
+
+public abstract class Mimis extends Component {
+    protected Component[] currentArray;
+    protected Manager manager;
+
+    protected ArrayCycle<Component> componentCycle;
+
+    public Mimis(Component... currentArray) {
+        this.currentArray = initialize(false, currentArray);        
+        componentCycle = new ArrayCycle<Component>(currentArray);        
+        router = new Router();
+        manager = new Manager(initialize(true, router, new Parser()));
+    }
+
+    public void activate() throws ActivateException {
+        manager.start();
+        super.activate();
+    }
+
+    protected void deactivate() throws DeactivateException {
+        super.deactivate();
+        manager.stop();
+    }
+
+    public void exit() {
+        super.exit();
+        manager.exit();
+    }
+
+    public Component[] initialize(boolean start, Component... componentArray) {
+        for (Component component : componentArray) {
+            component.setRouter(router);
+            if (start) {
+                component.start();
+            }
+        }
+        return componentArray;
+    }
+
+    public void task(Task task) {
+        if (task.getTarget().equals(Target.CURRENT)) {
+            componentCycle.current().add(task);
+        } else {
+            super.task(task);
+        }
+    }
+
+    public void end(Action action) {
+        switch (action) {
+            case CURRENT:
+                route(new Feedback("Current component: " + componentCycle.current().getTitle()));
+                break;
+            case NEXT:
+                log.debug("Next component");
+                route(new Feedback("Next component: " + componentCycle.next().getTitle()));
+                break;
+            case PREVIOUS:
+                log.debug("Previous component");
+                route(new Feedback("Previous component: " + componentCycle.previous().getTitle()));
+                break;
+            case EXIT:
+                exit();
+                break;
+			default:
+				break;
+        }
+    }
+}

java/mimis/src/main/java/mimis/application/Application.java

@@ -0,0 +1,6 @@
+package mimis.application;
+
+
+public interface Application {
+
+}

java/mimis/src/main/java/mimis/application/cmd/CMDApplication.java

@@ -0,0 +1,80 @@
+package mimis.application.cmd;
+
+import java.io.IOException;
+import java.util.Map;
+
+import mimis.application.Application;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.util.Native;
+import mimis.value.Registry;
+import mimis.worker.Component;
+
+public abstract class CMDApplication extends Component implements Application {
+    protected final static Registry REGISTRY = Registry.LOCAL_MACHINE;
+    protected final static String KEY = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths";
+
+    protected String program;
+    protected String title;
+    protected Process process;
+    protected boolean detect, running;
+
+    public CMDApplication(String program, String title) {
+        super(title);
+        this.program = program;
+        this.title = title;
+        detect = true;
+    }
+
+    protected void activate() throws ActivateException {
+        detect = true;
+        if (!running) {
+            String path = getPath();
+            if (path == null) {
+                throw new ActivateException();
+            }
+            try {
+                String command = path.startsWith("\"") ? path : String.format("\"%s\"", path);
+                command = replaceVariables(command);
+                process = Runtime.getRuntime().exec(command);
+            } catch (IOException e) {
+                log.error(e);
+                throw new ActivateException();
+            }
+        }
+        super.activate();
+    }
+
+    public boolean active() {
+        if (detect) {
+            running = Native.isRunning(program);
+            if (!active && running) {
+                active = true;
+                start();
+            }
+        }
+        return active;
+    }
+
+    protected synchronized void deactivate() throws DeactivateException {
+        detect = false;
+        super.deactivate();
+        if (process != null) {
+            process.destroy();
+        }
+    }
+
+    public String getPath() {
+        String key = String.format("%s\\%s", KEY, program);
+        System.out.println(Native.getValue(REGISTRY, key));
+        return Native.getValue(REGISTRY, key);         
+    }
+
+    public static String replaceVariables(String string) {
+        Map<String, String> env = System.getenv();
+        for (String key : env.keySet()) {
+            string = string.replace(String.format("%%%s%%", key), env.get(key));
+        }
+        return string;
+    }
+}

java/mimis/src/main/java/mimis/application/cmd/windows/WindowsApplication.java

@@ -0,0 +1,100 @@
+package mimis.application.cmd.windows;
+
+import mimis.application.cmd.CMDApplication;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.util.Native;
+import mimis.value.Command;
+import mimis.value.Key;
+import mimis.value.Type;
+import mimis.value.Windows;
+
+public abstract class WindowsApplication extends CMDApplication {
+    protected final static int TERMINATE_SLEEP = 500;
+    protected final static int START_SLEEP = 500;
+
+    protected String window;
+    protected int handle;
+
+    public WindowsApplication(String title, String window) {
+        this(null, title, window);
+    }
+
+    public WindowsApplication(String program, String title, String window) {
+        super(program, title);
+        this.window = window;
+        handle = 0;
+    }
+
+    protected void activate() throws ActivateException {
+        if (program != null) {
+            super.activate();
+        }
+        handle = Native.getHandle(window);
+        if (handle < 1) {
+            sleep(START_SLEEP);
+            handle = Native.getHandle(window);
+        }
+        active = handle > 0;
+        if (!active) {
+            throw new ActivateException();
+        }
+    }
+
+    public boolean active() {
+        if (!active || program == null) {
+            handle = Native.getHandle(window);
+            if (handle > 0 && program == null) {
+                start();
+            }
+        }
+        return program == null ? handle > 0 : super.active();
+    }
+
+    protected void deactivate() throws DeactivateException {
+        if (process == null) {
+            active = false;
+        } else {
+            super.deactivate();
+        }
+        close();
+    }
+
+    protected void close() {
+        Native.sendMessage(handle, Windows.WM_CLOSE, 0, 0);
+    }
+
+    protected void command(Command command) {
+        Native.sendMessage(handle, Windows.WM_APPCOMMAND, handle, command.getCode() << 16);
+    }
+
+    protected void command(int command) {
+        Native.sendMessage(handle, Windows.WM_COMMAND, command, 0);
+    }
+
+    protected int user(int wParam, int lParam) {
+        return Native.sendMessage(handle, Windows.WM_USER, wParam, lParam);
+    }
+
+    protected void system(Command.System system) {
+        system(system, 0);
+    }
+
+    protected void system(Command.System system, int lParam) {
+        Native.sendMessage(handle, Windows.WM_SYSCOMMAND, system.getCode(), lParam);
+    }
+
+    protected void key(Type type, int code) {
+        int scanCode = Native.mapVirtualKey(code, Windows.MAPVK_VK_TO_VSC);
+        Native.postMessage(handle, type.getCode(), code, 1 | (scanCode << 16) | 1 << 30);
+        sleep(200);
+    }
+
+    protected void key(Type type, char character) {
+        key(type, (int) Character.toUpperCase(character));
+    }
+
+    protected void key(Type key, Key virtualKey) {
+        key(key, virtualKey.getCode());
+    }
+}

java/mimis/src/main/java/mimis/application/cmd/windows/gomplayer/GomPlayerApplication.java

@@ -0,0 +1,127 @@
+package mimis.application.cmd.windows.gomplayer;
+
+import mimis.application.cmd.windows.WindowsApplication;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.value.Action;
+import mimis.value.Amount;
+import mimis.worker.Worker;
+
+public class GomPlayerApplication extends WindowsApplication {
+    protected final static String PROGRAM = "GOM.exe";
+    protected final static String TITLE = "GOM Player";
+    protected final static String WINDOW = "GomPlayer1.x";
+
+    protected static final int VOLUME_SLEEP = 100;
+    protected static final int SEEK_SLEEP = 100;
+
+    protected VolumeWorker volumeWorker;
+    protected SeekWorker seekWorker;
+
+    public GomPlayerApplication() {
+        super(PROGRAM, TITLE, WINDOW);
+        volumeWorker = new VolumeWorker();
+        seekWorker = new SeekWorker();
+    }
+
+    protected void deactivate() throws DeactivateException {
+        super.deactivate();
+        volumeWorker.stop();
+        seekWorker.stop();
+    }
+
+    public void exit() {
+        super.exit();
+        volumeWorker.exit();
+        seekWorker.exit();
+    }
+
+    public void begin(Action action) {
+        log.trace("GomPlayerApplication begin: " + action);
+        switch (action) {
+            case VOLUME_UP:
+                volumeWorker.start();    
+                break;
+            case VOLUME_DOWN:
+                volumeWorker.start();
+                break;
+            case FORWARD:
+                seekWorker.start(Amount.SMALL, 1);
+                break;
+            case REWIND:
+                seekWorker.start(Amount.SMALL, -1);
+                break;
+            case NEXT:
+                seekWorker.start(Amount.MEDIUM, 1);
+                break;
+            case PREVIOUS:
+                seekWorker.start(Amount.MEDIUM, -1);
+                break;  
+        }
+    }
+
+    public void end(Action action) {
+        log.trace("GomPlayerApplication end: " + action);
+        switch (action) {
+            case PLAY:
+                command(0x800C);
+                break;
+            case MUTE:
+                command(0x8016);
+                break;
+            case FORWARD:
+            case REWIND:
+            case NEXT:
+            case PREVIOUS:
+                seekWorker.stop();
+                break;
+            case VOLUME_UP:
+            case VOLUME_DOWN:
+                volumeWorker.stop();
+                break;
+            case FULLSCREEN:
+                command(0x8154);
+                break;
+        }
+    }
+
+    protected class VolumeWorker extends Worker {
+        protected int volumeChangeSign;
+
+        public void start(int volumeChangeSign) throws ActivateException {
+            super.start();
+            this.volumeChangeSign = volumeChangeSign;
+        }
+
+        public void work() {
+            command(volumeChangeSign > 0 ? 0x8014 : 0x8013);
+            sleep(VOLUME_SLEEP);
+        }
+    };
+
+    protected class SeekWorker extends Worker {
+        protected Amount amount;
+        protected int seekDirection;
+
+        public void start(Amount amount, int seekDirection) {
+            super.start();
+            this.amount = amount;
+            this.seekDirection = seekDirection;
+        }
+
+        public void work() {
+            switch (amount) {
+                case SMALL:
+                    command(seekDirection > 0 ? 0x8009 : 0x8008);
+                    break;
+                case MEDIUM:
+                    command(seekDirection > 0 ? 0x800B : 0x800A);
+                    break;
+                case LARGE:
+                    command(seekDirection > 0 ? 0x8012 : 0x8011);
+                    break;
+            }
+            sleep(SEEK_SLEEP);
+        }
+    };
+}

java/mimis/src/main/java/mimis/application/cmd/windows/photoviewer/PhotoViewerApplication.java

@@ -0,0 +1,110 @@
+package mimis.application.cmd.windows.photoviewer;
+
+import mimis.application.cmd.windows.WindowsApplication;
+import mimis.exception.worker.DeactivateException;
+import mimis.value.Action;
+import mimis.value.Key;
+import mimis.value.Type;
+import mimis.worker.Worker;
+
+public class PhotoViewerApplication extends WindowsApplication {
+    protected final static String TITLE = "Photo Viewer";
+    protected final static String WINDOW = "Photo_Lightweight_Viewer";
+
+    protected static final int ZOOM_SLEEP = 100;
+    protected static final int DELETE_SLEEP = 2000;
+
+    protected ZoomWorker zoomWorker;
+    protected boolean fullscreen;
+
+    public PhotoViewerApplication() {
+        super(TITLE, WINDOW);
+        zoomWorker = new ZoomWorker();
+        fullscreen = false;
+    }
+
+    protected void deactivate() throws DeactivateException {
+        super.deactivate();
+        zoomWorker.stop();
+    }
+
+    public void exit() {
+        super.exit();
+        zoomWorker.exit();
+    }
+
+    public void begin(Action action) {
+        switch (action) {
+            case VOLUME_UP:
+                zoomWorker.start(1);    
+                break;
+            case VOLUME_DOWN:
+                zoomWorker.start(-1);
+                break;
+        }
+    }
+
+    public void end(Action action) {
+        log.trace("PhotoViewerApplication end: " + action);
+        switch (action) {
+            case VOLUME_UP:
+            case VOLUME_DOWN:
+                zoomWorker.stop();
+                break;
+            case NEXT:
+                key(Type.DOWN, Key.RIGHT);
+                break;
+            case PREVIOUS:
+                key(Type.DOWN, Key.LEFT);
+                break;
+            case FORWARD:
+                key(Type.DOWN, Key.CONTROL);
+                //key(Type.DOWN, '.');
+                //key(Type.DOWN, Key.DECIMAL);
+                key(Type.DOWN, Key.OEM_PERIOD);
+                //key(Type.UP, Key.OEM_PERIOD);
+                //key(Type.UP, Key.CONTROL);
+                break;
+            case MUTE:
+                key(Type.DOWN, Key.CONTROL);
+                key(Type.DOWN, Key.NUMPAD0);
+                //press(Key.CONTROL);
+                //press(Key.NUMPAD0);
+                //release(Key.CONTROL);
+                break;
+            case FULLSCREEN:
+                key(Type.DOWN, fullscreen ? Key.ESCAPE : Key.F11);
+                fullscreen = !fullscreen;
+                break;
+            case DISLIKE:
+                /*boolean restore = false;
+                if (fullscreen) {
+                    end(Action.FULLSCREEN);
+                    sleep(DELETE_SLEEP);
+                    restore = true;
+                }
+                key(Type.DOWN, Key.F16);
+                key(Type.DOWN, 'Y');
+                if (restore) {
+                    sleep(DELETE_SLEEP);
+                    end(Action.FULLSCREEN);
+                }*/
+                break;
+        }
+    }
+
+    protected class ZoomWorker extends Worker {
+        protected int zoomDirection;
+
+        public void start(int zoomDirection) {
+            super.start();
+            this.zoomDirection = zoomDirection;
+        }
+
+        public void work() {
+            Key key = zoomDirection > 0 ? Key.ADD : Key.SUBTRACT;
+            key(Type.DOWN, key);
+            sleep(ZOOM_SLEEP);
+        }
+    }
+}

java/mimis/src/main/java/mimis/application/cmd/windows/winamp/WinampApplication.java

@@ -0,0 +1,181 @@
+package mimis.application.cmd.windows.winamp;
+
+import mimis.application.cmd.windows.WindowsApplication;
+import mimis.exception.worker.DeactivateException;
+import mimis.value.Action;
+import mimis.value.Command;
+import mimis.worker.Worker;
+
+public class WinampApplication extends WindowsApplication {
+    protected final static String PROGRAM = "winamp.exe";
+    protected final static String TITLE = "Winamp";
+    protected final static String WINDOW = "Winamp v1.x";
+
+    protected final static int STATUS_PLAYING = 1;
+    protected final static int STATUS_PAUSED = 3;
+    protected final static int STATUS_STOPPED = 0;
+
+    protected final static int IPC_ISPLAYING = 104;
+    protected final static int IPC_GETOUTPUTTIME = 105;
+    protected final static int IPC_SETVOLUME = 122;
+
+    protected final static int WINAMP_FILE_QUIT     = 40001;
+    protected final static int WINAMP_FILE_REPEAT   = 40022;
+    protected final static int WINAMP_FILE_SHUFFLE  = 40023;
+    protected final static int WINAMP_BUTTON1       = 40044;
+    protected final static int WINAMP_BUTTON2       = 40045;
+    protected final static int WINAMP_BUTTON3       = 40046;
+    protected final static int WINAMP_BUTTON5       = 40048;   
+    protected final static int WINAMP_VOLUMEUP      = 40058;
+    protected final static int WINAMP_VOLUMEDOWN    = 40059;
+    protected final static int WINAMP_FFWD5S        = 40060;
+    protected final static int WINAMP_REW5S         = 40061;
+    protected final static int WINAMP_BUTTON4_SHIFT = 40147;
+    protected final static int WINAMP_VISPLUGIN     = 40192;
+
+    protected static final int VOLUME_SLEEP = 50;
+    protected static final int SEEK_SLEEP = 100;
+
+    protected VolumeWorker volumeWorker;
+    protected SeekWorker seekWorker;
+    protected double volume;
+    protected boolean muted;
+
+    public WinampApplication() {
+        super(PROGRAM, TITLE, WINDOW);
+        volume = getVolume();
+        muted = volume == 0;
+        volumeWorker = new VolumeWorker();
+        seekWorker = new SeekWorker();
+    }
+
+    public void deactivate() throws DeactivateException {
+        super.deactivate();
+        volumeWorker.stop();
+        seekWorker.stop();
+    }
+
+    public void exit() {
+        super.exit();
+        volumeWorker.exit();
+        seekWorker.exit();
+    }
+
+    public void begin(Action action) {
+        log.trace("WinampApplication begin: " + action);
+        switch (action) {
+            case VOLUME_UP:
+                volumeWorker.start(1);
+                break;
+            case VOLUME_DOWN:
+                volumeWorker.start(-1);
+                break;
+            case FORWARD:
+                seekWorker.start(1);
+                break;
+            case REWIND:
+                seekWorker.start(-1);
+                break;
+        }
+    }
+
+    public void end(Action action) {
+        log.trace("WinampApplication end: " + action);
+        switch (action) {
+            case PLAY:
+                log.debug("play");
+                switch (user(0, IPC_ISPLAYING)) {
+                    case STATUS_STOPPED:
+                        command(WINAMP_BUTTON2);
+                        break;
+                    default:
+                        command(WINAMP_BUTTON3);
+                        break;
+                }                
+                break;
+            case NEXT:
+                command(WINAMP_BUTTON5);
+                break;
+            case PREVIOUS:
+                command(WINAMP_BUTTON1);
+                break;
+            case FORWARD:
+            case REWIND:
+                seekWorker.stop();
+                break;
+            case MUTE:
+                if (muted) {
+                    setVolume(volume);
+                } else {
+                    volume = getVolume();
+                    setVolume(0);
+                }
+                muted = !muted;
+                break;
+            case VOLUME_UP:
+            case VOLUME_DOWN:
+                volumeWorker.stop();
+                break;
+            case SHUFFLE:
+                command(WINAMP_FILE_SHUFFLE);
+                break;
+            case REPEAT:
+                command(WINAMP_FILE_REPEAT);
+                break;
+            case FADEOUT:
+                command(WINAMP_BUTTON4_SHIFT);
+                break;
+            case QUIT:
+                command(WINAMP_FILE_QUIT);
+                break;
+            case VISUALISER:
+                system(Command.System.MAXIMIZE);
+                command(WINAMP_VISPLUGIN);
+                break;
+        }
+    }
+
+    public double getVolume() {
+        return user(-666, IPC_SETVOLUME) / 255f;
+    }
+
+    public void setVolume(double volume) {
+        user((int) Math.ceil(volume * 255), IPC_SETVOLUME);
+    }
+
+    public int getDuration() {
+        return user(1, IPC_GETOUTPUTTIME);
+    }
+
+    public int getElapsed() {
+        return user(0, IPC_GETOUTPUTTIME) / 1000;
+    }
+
+    protected class VolumeWorker extends Worker {
+        protected int volumeChangeSign;
+
+        public void start(int volumeChangeSign) {
+            super.start();
+            this.volumeChangeSign = volumeChangeSign;
+        }
+
+        public void work() {
+            command(volumeChangeSign > 0 ? WINAMP_VOLUMEUP : WINAMP_VOLUMEDOWN);
+            sleep(VOLUME_SLEEP);
+        }
+    };
+
+    protected class SeekWorker extends Worker {
+        protected int seekDirection;
+
+        public void start(int seekDirection) {
+            super.start();
+            this.seekDirection = seekDirection;
+        }
+
+        public void work() {
+            command(seekDirection > 0 ? WINAMP_FFWD5S : WINAMP_REW5S);
+            sleep(SEEK_SLEEP);
+        }
+    };
+}

java/mimis/src/main/java/mimis/application/cmd/windows/wmp/WMPApplication.java

@@ -0,0 +1,86 @@
+package mimis.application.cmd.windows.wmp;
+
+import mimis.application.cmd.windows.WindowsApplication;
+import mimis.value.Action;
+import mimis.worker.Worker;
+
+public class WMPApplication extends WindowsApplication {
+    protected final static String PROGRAM = "wmplayer.exe";
+    protected final static String TITLE = "Windows Media Player";
+    protected final static String WINDOW = "WMPlayerApp";
+
+    protected static final int VOLUME_SLEEP = 120;
+
+    protected VolumeWorker volumeWorker;
+    
+    public WMPApplication() {
+        super(PROGRAM, TITLE, WINDOW);
+        volumeWorker = new VolumeWorker();
+    }
+
+    public void begin(Action action) {
+        log.trace("WMPApplication begin: " + action);
+        switch (action) {
+            case PLAY:
+                command(18808);
+                break;
+            case NEXT:
+                command(18811);
+                break;
+            case PREVIOUS:
+                command(18810);
+                break;
+            case FORWARD:
+                command(18813);
+                break;
+            case REWIND:
+                command(18812);
+                break;
+            case MUTE:
+                command(18817);
+                break;
+            case VOLUME_UP:
+                volumeWorker.start(1);
+                break;
+            case VOLUME_DOWN:
+                volumeWorker.start(-1);
+                break;
+            case SHUFFLE:
+                command(18842);
+                break;
+            case REPEAT:
+                command(18843);
+                break;
+        }
+    }
+
+    public void end(Action action) {
+        log.trace("WMPApplication end: " + action);
+        switch (action) {
+            case FORWARD:
+                command(18813);
+                break;
+            case REWIND:
+                command(18812);
+                break;
+            case VOLUME_UP:
+            case VOLUME_DOWN:
+                volumeWorker.stop();
+                break;
+        }
+    }
+
+    protected class VolumeWorker extends Worker {
+        protected int volumeChangeSign;
+
+        public void start(int volumeChangeSign) {
+            super.start();
+            this.volumeChangeSign = volumeChangeSign;
+        }
+
+        public void work() {
+            command (volumeChangeSign > 0 ? 18815 : 18816);
+            sleep(VOLUME_SLEEP);
+        }
+    };
+}

java/mimis/src/main/java/mimis/application/itunes/iTunesApplication.java

@@ -0,0 +1,177 @@
+package mimis.application.itunes;
+
+import mimis.application.Application;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.value.Action;
+import mimis.worker.Component;
+import mimis.worker.Worker;
+
+import com.dt.iTunesController.ITCOMDisabledReason;
+import com.dt.iTunesController.ITTrack;
+import com.dt.iTunesController.iTunes;
+import com.dt.iTunesController.iTunesEventsInterface;
+
+public class iTunesApplication extends Component implements Application, iTunesEventsInterface {
+    protected static final String TITLE = "iTunes";
+    protected static final boolean EVENTS = false;
+
+    protected static final int VOLUME_CHANGE_RATE = 5;
+    protected static final int VOLUME_SLEEP = 100;
+    protected static final String PLAYLIST_LIKE = "Like";
+    protected static final String PLAYLIST_DISLIKE = "Dislike";
+
+    protected iTunes iTunes;
+    protected VolumeWorker volumeWorker;
+    protected boolean events;
+
+    public iTunesApplication() {
+        this(EVENTS);
+    }
+
+    public iTunesApplication(boolean events) {
+        super(TITLE);
+        this.events = events;
+        volumeWorker = new VolumeWorker();
+    }
+
+    protected synchronized void activate() throws ActivateException {
+        iTunes = new iTunes();
+        iTunes.connect();
+        if (events) {
+            iTunes.addEventHandler(this);
+        }
+        super.activate();
+    }
+
+    public synchronized boolean active() {
+        try {
+            iTunes.getMute();
+            active = true;
+        } catch (Exception e) {
+            active = false;
+        }
+        return active;
+    }
+
+    protected synchronized void deactivate() throws DeactivateException  {
+        if (events) {
+            exit();
+        } else {
+            super.deactivate();
+            volumeWorker.stop();
+            try {
+                iTunes.release();
+            } catch (Exception e) {
+                log.error(e);
+                throw new DeactivateException();
+            }
+        }
+    }
+
+    public synchronized void exit() {
+        try {
+            iTunes.quit();
+        } catch (Exception e) {}
+        volumeWorker.exit();
+        super.exit();
+    }
+
+    protected void begin(Action action) {
+        log.trace("iTunesApplication begin: " + action);
+        if (!active) return;
+        switch (action) {
+            case FORWARD:
+                iTunes.fastForward();
+                break;
+            case REWIND:
+                iTunes.rewind();
+                break;
+            case VOLUME_UP:
+                volumeWorker.start(VOLUME_CHANGE_RATE);
+                break;
+            case VOLUME_DOWN:
+                volumeWorker.start(-VOLUME_CHANGE_RATE);
+                break;
+        }
+    }
+
+    protected void end(Action action) {
+        log.trace("iTunesApplication end: " + action);
+        if (!active) return;
+        switch (action) {
+            case PLAY:
+                iTunes.playPause();
+                break;
+            case NEXT:
+                iTunes.nextTrack();
+                break;
+            case PREVIOUS:
+                iTunes.previousTrack();
+                break;
+            case FORWARD:
+                iTunes.resume();
+                break;
+            case REWIND:
+                iTunes.resume();
+                break;
+            case MUTE:
+                iTunes.toggleMute();
+                break;
+            case VOLUME_UP:
+            case VOLUME_DOWN:
+                volumeWorker.stop();
+                break;
+            case SHUFFLE:
+                iTunes.toggleShuffle();
+                break;
+            case REPEAT:
+                iTunes.cycleSongRepeat();
+                break;
+            case LIKE:
+                iTunes.playlistAddCurrentTrack(PLAYLIST_LIKE);
+                break;
+            case DISLIKE:
+                iTunes.playlistAddCurrentTrack(PLAYLIST_DISLIKE);
+                break;
+        }
+    }
+
+    protected int getVolume() {
+        return iTunes.getSoundVolume();
+    }
+
+    public void onDatabaseChangedEvent(int[][] deletedObjectIDs, int[][] changedObjectIDs) {}
+    public void onPlayerPlayEvent(ITTrack iTrack) {
+        if (active) {
+            log.trace("iTunesEvent: play");
+        }
+    }
+
+    public void onPlayerStopEvent(ITTrack iTrack) {
+        if (active) {
+            log.trace("iTunesEvent: stop");
+        }
+    }
+
+    public void onPlayerPlayingTrackChangedEvent(ITTrack iTrack) {}
+    public void onCOMCallsDisabledEvent(ITCOMDisabledReason reason) {}
+    public void onCOMCallsEnabledEvent() {}
+    public void onQuittingEvent() {}
+    public void onAboutToPromptUserToQuitEvent() {}
+    public void onSoundVolumeChangedEvent(int newVolume) {}    
+
+    protected class VolumeWorker extends Worker {
+        protected int volumeChangeRate;
+
+        public void start(int volumeChangeRate) {
+            super.start();
+            this.volumeChangeRate = volumeChangeRate;
+        }
+
+        public void work() {
+            iTunes.setSoundVolume(getVolume() + volumeChangeRate);
+            sleep(VOLUME_SLEEP);
+        }
+    };
+}

java/mimis/src/main/java/mimis/application/lirc/LircApplication.java

@@ -0,0 +1,42 @@
+package mimis.application.lirc;
+
+import mimis.application.Application;
+import mimis.device.lirc.LircButton;
+import mimis.device.lirc.LircService;
+import mimis.device.lirc.remote.WC02IPOButton;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.worker.Component;
+
+public class LircApplication extends Component implements Application {
+    protected LircService lircService;
+
+    public LircApplication(String title) {
+        super(title);
+        lircService = new LircService();
+        lircService.put(WC02IPOButton.NAME, WC02IPOButton.values());
+    }
+
+    public void activate() throws ActivateException {
+        lircService.activate();
+        super.activate();
+    }
+
+    public boolean active() {
+        return active = lircService.active();
+    }
+
+    protected void deactivate() throws DeactivateException  {
+        super.deactivate();
+        lircService.stop();
+    }
+
+    public void exit() {
+        super.exit();
+        lircService.exit();
+    }
+
+    public void send(LircButton button) {
+        lircService.send(button);
+    }
+}

java/mimis/src/main/java/mimis/application/lirc/ipod/iPodApplication.java

@@ -0,0 +1,86 @@
+package mimis.application.lirc.ipod;
+
+import mimis.application.lirc.LircApplication;
+import mimis.device.lirc.remote.WC02IPOButton;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.value.Action;
+import mimis.worker.Worker;
+
+public class iPodApplication extends LircApplication {
+    protected static final String TITLE = "iPod";
+    protected static final int VOLUME_SLEEP = 100;
+
+    protected VolumeWorker volumeWorker;
+
+    public iPodApplication() {
+        super(TITLE);
+        volumeWorker = new VolumeWorker();
+    }
+
+    protected void deactivate() throws DeactivateException {
+        super.deactivate();
+        volumeWorker.stop();
+    }
+
+    public void exit() {
+        super.exit();
+        volumeWorker.exit();
+    }
+
+    protected void begin(Action action) {
+        log.trace("iPodApplication begin: " + action);
+        if (!active) return;
+        switch (action) {
+            case VOLUME_UP:
+                try {
+                    volumeWorker.activate(1);
+                } catch (ActivateException e) {
+                    log.error(e);
+                }
+                break;
+            case VOLUME_DOWN:
+                try {
+                    volumeWorker.activate(-1);
+                } catch (ActivateException e) {
+                    log.error(e);
+                }
+                break;
+        }
+    }
+
+    protected void end(Action action) {
+        log.trace("iPodApplication end: " + action);
+        if (!active) return;
+        switch (action) {
+            case PLAY:
+                send(WC02IPOButton.PLAY);
+                break;
+            case NEXT:
+                send(WC02IPOButton.NEXT);
+                break;
+            case PREVIOUS:
+                send(WC02IPOButton.PREVIOUS);
+                break;
+            case VOLUME_UP:
+            case VOLUME_DOWN:
+                volumeWorker.stop();
+                break;
+        }
+    }
+
+    protected class VolumeWorker extends Worker {
+        protected int volumeChangeRate;
+
+        public void activate(int volumeChangeRate) throws ActivateException {
+            super.activate();
+            this.volumeChangeRate = volumeChangeRate;
+            send(volumeChangeRate > 0 ? WC02IPOButton.PLUS : WC02IPOButton.MINUS);
+        }
+
+        public void work() {
+            lircService.send(WC02IPOButton.HOLD);
+            sleep(VOLUME_SLEEP);
+        }
+    };
+}

java/mimis/src/main/java/mimis/application/mpc/MPCApplication.java

@@ -0,0 +1,102 @@
+package mimis.application.mpc;
+
+import mimis.application.cmd.windows.WindowsApplication;
+import mimis.value.Action;
+import mimis.worker.Worker;
+
+public class MPCApplication extends WindowsApplication {
+    protected final static String PROGRAM = "mpc-hc.exe";
+    protected final static String TITLE = "Media Player Classic";
+    protected final static String WINDOW = "MediaPlayerClassicW";
+    
+    protected static final int VOLUME_SLEEP = 50;
+    protected static final int SEEK_SLEEP = 50;
+
+    protected VolumeWorker volumeWorker;
+    protected SeekWorker seekWorker;
+    
+    public MPCApplication() {
+        super(PROGRAM, TITLE, WINDOW);
+        volumeWorker = new VolumeWorker();
+        seekWorker = new SeekWorker();
+    }
+
+    public void begin(Action action) {
+        log.trace("MPCApplication: " + action);
+        switch (action) {
+           case FORWARD:
+                seekWorker.start(1);
+                break;
+            case REWIND:
+                seekWorker.start(-1);
+                break;
+            case VOLUME_UP:
+                volumeWorker.start(1);
+                break;
+            case VOLUME_DOWN:
+                volumeWorker.start(-1);
+                break;
+        }
+    }
+    
+    public void end(Action action) {
+        log.trace("MPCApplication: " + action);
+        switch (action) {
+            case PLAY:
+                command(889);
+                break;
+            case NEXT:
+                command(921);
+                break;
+            case PREVIOUS:
+                command(920);
+                break;
+            case FORWARD:
+            case REWIND:
+                seekWorker.stop();
+                break;
+            case MUTE:
+                command(909);
+                break;
+            case VOLUME_UP:
+            case VOLUME_DOWN:
+                volumeWorker.stop();
+                break;
+            case FULLSCREEN:
+                command(830);
+                break;
+        }
+    }
+
+    public String getTitle() {
+        return TITLE;
+    }
+
+    protected class VolumeWorker extends Worker {
+        protected int volumeChangeSign;
+
+        public void start(int volumeChangeSign)  {
+            super.start();
+            this.volumeChangeSign = volumeChangeSign;
+        }
+
+        public void work() {
+            command(volumeChangeSign > 0 ? 907 : 908);
+            sleep(VOLUME_SLEEP);
+        }
+    };
+
+    protected class SeekWorker extends Worker {
+        protected int seekDirection;
+
+        public void start(int seekDirection) {
+            super.start();
+            this.seekDirection = seekDirection;
+        }
+
+        public void work() {
+            command(seekDirection > 0 ? 900 : 889);
+            sleep(SEEK_SLEEP);
+        }
+    };    
+}

java/mimis/src/main/java/mimis/application/robot/RobotApplication.java

@@ -0,0 +1,35 @@
+package mimis.application.robot;
+
+import java.awt.AWTException;
+import java.awt.Robot;
+
+import mimis.exception.worker.ActivateException;
+import mimis.value.Key;
+import mimis.worker.Component;
+
+public class RobotApplication extends Component {
+    protected Robot robot;
+
+    public void activate() throws ActivateException {
+        try {
+            robot = new Robot();
+            robot.setAutoWaitForIdle(true);
+        } catch (AWTException e) {
+            log.error(e);
+            throw new ActivateException();
+        }
+        super.activate();
+    }
+
+    public void press(Key key) {
+        robot.keyPress(key.getCode());
+    }
+
+    public void press(char key) {
+        robot.keyPress(key);
+    }
+
+    public void release(Key key) {
+        robot.keyRelease(key.getCode());
+    }
+}

java/mimis/src/main/java/mimis/application/vlc/VLCApplication.java

@@ -0,0 +1,198 @@
+package mimis.application.vlc;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import mimis.application.cmd.CMDApplication;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.util.Native;
+import mimis.value.Action;
+import mimis.value.Amount;
+import mimis.value.Registry;
+import mimis.worker.Worker;
+
+public class VLCApplication extends CMDApplication {
+    protected final static Registry REGISTRY = Registry.CLASSES_ROOT;
+    protected final static String KEY = "Applications\\vlc.exe\\shell\\Open\\command";
+    protected final static String PROGRAM = "vlc.exe";
+    protected final static String TITLE = "VLC media player";
+
+    protected static final int POSTION_CHANGE_RATE = 1;
+    protected static final int VOLUME_CHANGE_RATE = 20;
+
+    protected static final String HOST = "localhost";
+    protected static final int PORT = 8080;
+
+    protected static final int VOLUME_SLEEP = 100;
+    protected static final int SEEK_SLEEP = 100;
+    
+    protected VolumeWorker volumeWorker;
+    protected SeekWorker seekWorker;
+    
+    protected int volume = 255;
+    protected boolean muted = false;
+
+    public VLCApplication() {
+        super(PROGRAM, TITLE);
+        volumeWorker = new VolumeWorker();
+        seekWorker = new SeekWorker();
+    }
+
+    public String getPath() {
+        Pattern pattern = Pattern.compile("\"([^\"]+)\"");
+        Matcher matcher = pattern.matcher(Native.getValue(REGISTRY, KEY));
+        return matcher.find() ? matcher.group(1) : null;
+    }
+
+    public void command(String command) {
+        String request = String.format("http://%s:%d/requests/status.xml?command=%s", HOST, PORT, command);
+        try {
+            URL url = new URL(request);
+            HttpURLConnection httpUrlConnection = (HttpURLConnection) url.openConnection();
+            int response = httpUrlConnection.getResponseCode();
+            log.trace("Response: " + response);
+        } catch (MalformedURLException e) {
+            log.error(e);
+        } catch (IOException e) {
+            log.error(e);
+        }
+    }
+
+    protected void deactivate() throws DeactivateException {
+        super.deactivate();
+        volumeWorker.stop();
+        seekWorker.stop();
+        Native.terminate(program);
+    }
+
+    public void exit() {
+        super.exit();
+        volumeWorker.exit();
+        seekWorker.exit();
+    }
+
+    public void begin(Action action) {
+        log.trace("VLCApplication begin: " + action);
+        try {
+            switch (action) {
+                case VOLUME_UP:                    
+                    volumeWorker.activate("+");    
+                    break;
+                case VOLUME_DOWN:
+                    volumeWorker.activate("-");
+                    break;
+                case FORWARD:
+                    seekWorker.start(Amount.SMALL, "+");
+                    break;
+                case REWIND:
+                    seekWorker.start(Amount.SMALL, "-");
+                    break;
+            }
+        } catch (ActivateException e) {
+            log.error(e);
+        }
+    }
+    
+    public void end(Action action) {
+        log.trace("VLCApplication end: " + action);
+        switch (action) {
+            case PLAY:
+                command("pl_pause");
+                break;
+            case PAUSE:
+                command("pl_pause");
+                break;
+            case NEXT:
+                command("pl_next");
+                break;
+            case PREVIOUS:
+                command("pl_previous");
+                break;
+            case FORWARD:
+            case REWIND:
+                seekWorker.stop();
+                break;
+            case MUTE:
+                command("volume&val=" + toggleMute());
+                break;
+            case VOLUME_UP:
+            case VOLUME_DOWN:
+                volumeWorker.stop();
+                break;
+            case SHUFFLE:
+                command("command=pl_random");
+                break;
+            case REPEAT:
+                command("command=pl_repeat");
+                break;
+        }
+    }
+    
+    protected void volumeUp() {
+        if (!muted) {
+            volume += VOLUME_CHANGE_RATE;
+            command("volume&val=+" + VOLUME_CHANGE_RATE);
+        }
+    }
+    
+    protected void volumeDown() {
+        if (!muted) {
+            volume -= VOLUME_CHANGE_RATE;
+            command("volume&val=-" + VOLUME_CHANGE_RATE);
+        }
+    }
+
+    protected int toggleMute() {
+        return (muted = !muted) ? 0 : volume;
+    }
+
+    public String getTitle() {
+        return TITLE;
+    }
+    
+    protected class VolumeWorker extends Worker {
+        protected String volumeChangeSign;
+
+        public void activate(String volumeChangeSign) throws ActivateException {
+            super.activate();
+            this.volumeChangeSign = volumeChangeSign;
+        }
+
+        public void work() {
+            volume += VOLUME_CHANGE_RATE;
+            command("volume&val=" + volumeChangeSign + VOLUME_CHANGE_RATE);
+            sleep(VOLUME_SLEEP);
+        }
+    };
+
+    protected class SeekWorker extends Worker {
+        protected Amount amount;
+        protected String seekDirection;
+
+        public void start(Amount amount, String seekDirection) {
+            super.start();
+            this.amount = amount;
+            this.seekDirection = seekDirection;
+        }
+
+        public void work() {
+            switch (amount) {
+                case SMALL:
+                    command("command=seek&val=" + seekDirection + POSTION_CHANGE_RATE);
+                    break;
+                case MEDIUM:
+                    command("command=seek&val=" + seekDirection + POSTION_CHANGE_RATE * 2);
+                    break;
+                case LARGE:
+                    command("command=seek&val=" + seekDirection + POSTION_CHANGE_RATE * 3);
+                    break;
+            }
+            sleep(SEEK_SLEEP);
+        }
+    };
+}

java/mimis/src/main/java/mimis/device/Device.java

@@ -0,0 +1,5 @@
+package mimis.device;
+
+public interface Device {
+
+}

java/mimis/src/main/java/mimis/device/javainput/DirectionButton.java

@@ -0,0 +1,39 @@
+package mimis.device.javainput;
+
+import mimis.input.Button;
+import mimis.exception.button.UnknownDirectionException;
+import de.hardcode.jxinput.event.JXInputDirectionalEvent;
+
+public enum DirectionButton implements Button {
+    NORTH     (0),
+    NORTHEAST (45),
+    EAST      (90),
+    SOUTHEAST (135),
+    SOUTH     (180),
+    SOUTHWEST (225),
+    WEST      (270),
+    NORTHWEST (315);
+
+    protected int code;
+
+    private DirectionButton(int code) {
+        this.code = code;
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public static DirectionButton create(int angle) throws UnknownDirectionException  {
+        for (DirectionButton button : DirectionButton.values()) {
+            if (button.getCode() == angle) {
+                return button;
+            }
+        }
+        throw new UnknownDirectionException();
+    }
+
+    public static DirectionButton create(JXInputDirectionalEvent event) throws UnknownDirectionException {
+        return create(event.getDirectional().getDirection() / 100);      
+    }
+}

java/mimis/src/main/java/mimis/device/javainput/JavaInputDevice.java

@@ -0,0 +1,85 @@
+package mimis.device.javainput;
+
+import mimis.device.Device;
+import mimis.exception.ButtonException;
+import mimis.exception.button.UnknownButtonException;
+import mimis.exception.button.UnknownDirectionException;
+import mimis.exception.device.DeviceNotFoundException;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.input.Button;
+import mimis.input.state.Press;
+import mimis.input.state.Release;
+import mimis.worker.Component;
+import de.hardcode.jxinput.JXInputDevice;
+import de.hardcode.jxinput.JXInputManager;
+import de.hardcode.jxinput.event.JXInputAxisEvent;
+import de.hardcode.jxinput.event.JXInputButtonEvent;
+import de.hardcode.jxinput.event.JXInputDirectionalEvent;
+
+public abstract class JavaInputDevice extends Component implements Device {
+    protected String name;
+
+    public JavaInputDevice(String title, String name) {
+        super(title);
+        this.name = name;
+    }
+
+    protected JavaInputListener javaInputListener;
+    protected Button previousDirectionalButton;
+
+    protected void activate() throws ActivateException {
+        super.activate();
+        try {
+            JXInputDevice jxinputDevice = getDevice(name);
+            log.debug(jxinputDevice);
+            javaInputListener = new JavaInputListener(this, jxinputDevice);
+        } catch (DeviceNotFoundException e) {
+            active = false;
+            throw new ActivateException();
+        }
+        javaInputListener.start();
+    }
+
+    protected void deactivate() throws DeactivateException {
+        super.deactivate();
+        javaInputListener.stop();
+    }
+
+    public void processEvent(JXInputAxisEvent event) {}
+
+    public void processEvent(JXInputButtonEvent event) throws ButtonException {
+        Button button = getButton(event);
+        if (event.getButton().getState()) {
+            route(new Press(button));
+        } else {
+            route(new Release(button));
+        }
+    }
+
+    public void processEvent(JXInputDirectionalEvent event) throws UnknownDirectionException {
+        Button button = getButton(event);
+        if (event.getDirectional().isCentered()) {
+            if (previousDirectionalButton != null) {
+                route(new Release(previousDirectionalButton));
+            }
+        } else {
+            route(new Press(button));
+            previousDirectionalButton = button;
+        }
+    }
+
+    protected abstract Button getButton(JXInputButtonEvent event) throws UnknownButtonException;
+    protected abstract Button getButton(JXInputDirectionalEvent event) throws UnknownDirectionException;
+
+    public static JXInputDevice getDevice(String name) throws DeviceNotFoundException {
+        int numberOfDevices = JXInputManager.getNumberOfDevices();
+        for (int i = 0; i < numberOfDevices; ++i) {
+            JXInputDevice device = JXInputManager.getJXInputDevice(i);
+            if (device.getName().startsWith(name)) {
+                return device;
+            }
+        }
+        throw new DeviceNotFoundException();
+    }
+}

java/mimis/src/main/java/mimis/device/javainput/JavaInputListener.java

@@ -0,0 +1,85 @@
+package mimis.device.javainput;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+import mimis.exception.ButtonException;
+import mimis.worker.Worker;
+import de.hardcode.jxinput.Button;
+import de.hardcode.jxinput.Directional;
+import de.hardcode.jxinput.JXInputDevice;
+import de.hardcode.jxinput.JXInputManager;
+import de.hardcode.jxinput.event.JXInputAxisEvent;
+import de.hardcode.jxinput.event.JXInputAxisEventListener;
+import de.hardcode.jxinput.event.JXInputButtonEvent;
+import de.hardcode.jxinput.event.JXInputButtonEventListener;
+import de.hardcode.jxinput.event.JXInputDirectionalEvent;
+import de.hardcode.jxinput.event.JXInputDirectionalEventListener;
+import de.hardcode.jxinput.event.JXInputEventManager;
+
+public class JavaInputListener extends Worker implements Runnable, JXInputAxisEventListener, JXInputButtonEventListener, JXInputDirectionalEventListener {
+    protected JavaInputDevice javaInputDevice;
+    protected JXInputDevice jxinputDevice;
+    protected Queue<JXInputAxisEvent> axisEventQueue;
+    protected Queue<JXInputButtonEvent> buttonEventQueue;
+    protected Queue<JXInputDirectionalEvent> directionalEventQueue;
+
+    public JavaInputListener(JavaInputDevice javaInputDevice, JXInputDevice jxinputDevice) {
+        this.javaInputDevice = javaInputDevice;
+        this.jxinputDevice = jxinputDevice;
+        axisEventQueue = new LinkedList<JXInputAxisEvent>();
+        buttonEventQueue = new LinkedList<JXInputButtonEvent>();
+        directionalEventQueue = new LinkedList<JXInputDirectionalEvent>();
+        addListeners();
+    }
+
+    protected void addListeners() {
+        /*for (int i = 0; i < jxinputDevice.getMaxNumberOfAxes(); ++i) {
+            Axis axis = jxinputDevice.getAxis(i);
+            if (axis != null) {
+                JXInputEventManager.addListener(this, axis);
+            }
+        }*/
+        for (int i = 0; i < jxinputDevice.getMaxNumberOfButtons(); ++i) {
+            Button button = jxinputDevice.getButton(i);
+            if (button != null) {
+                JXInputEventManager.addListener(this, button);
+            }
+        }
+        for (int i = 0; i < jxinputDevice.getMaxNumberOfDirectionals(); ++i) {
+            Directional directional = jxinputDevice.getDirectional(i);
+            if (directional != null) {
+                JXInputEventManager.addListener(this, directional);
+            }
+        }
+    }
+
+    public void changed(JXInputAxisEvent event) {
+        axisEventQueue.add(event);    
+    }
+
+    public void changed(JXInputButtonEvent event) {
+        buttonEventQueue.add(event);
+    }
+
+    public void changed(JXInputDirectionalEvent event) {
+        directionalEventQueue.add(event);        
+    }
+
+    public void work() {
+        JXInputManager.updateFeatures();
+        if (!axisEventQueue.isEmpty()) {
+            javaInputDevice.processEvent(axisEventQueue.poll());
+        } else if (!buttonEventQueue.isEmpty()) {
+            try {
+                javaInputDevice.processEvent(buttonEventQueue.poll());
+            } catch (ButtonException e) {}
+        } else if (!directionalEventQueue.isEmpty()) {
+            try {
+                javaInputDevice.processEvent(directionalEventQueue.poll());
+            } catch (ButtonException e) {}
+        } else {
+            sleep();
+        }
+    }
+}

java/mimis/src/main/java/mimis/device/javainput/extreme3d/Extreme3DButton.java

@@ -0,0 +1,43 @@
+package mimis.device.javainput.extreme3d;
+
+import mimis.exception.button.UnknownButtonException;
+import mimis.input.Button;
+import de.hardcode.jxinput.event.JXInputButtonEvent;
+
+public enum Extreme3DButton implements Button {
+    ONE    ("Button 0"),
+    TWO    ("Button 1"),
+    THREE  ("Button 2"),
+    FOUR   ("Button 3"),
+    FIVE   ("Button 4"),
+    SIX    ("Button 5"),
+    SEVEN  ("Button 6"),
+    EIGHT  ("Button 7"),
+    NINE   ("Button 8"),
+    TEN    ("Button 9"),
+    ELEVEN ("Button 10"),
+    TWELVE ("Button 11");
+
+    protected String code;
+
+    private Extreme3DButton(String code) {
+        this.code = code;
+    }
+
+    public String getCode() {
+        return code;
+    }
+
+    public static Extreme3DButton create(String code) throws UnknownButtonException {
+        for (Extreme3DButton button : Extreme3DButton.values()) {
+            if (button.getCode().equals(code)) {
+                return button;
+            }
+        }
+        throw new UnknownButtonException();
+    }
+
+    public static Extreme3DButton create(JXInputButtonEvent event) throws UnknownButtonException {
+        return create(event.getButton().getName());      
+    }
+}

java/mimis/src/main/java/mimis/device/javainput/extreme3d/Extreme3DDevice.java

@@ -0,0 +1,38 @@
+package mimis.device.javainput.extreme3d;
+
+import mimis.device.javainput.DirectionButton;
+import mimis.device.javainput.JavaInputDevice;
+import mimis.exception.button.UnknownButtonException;
+import mimis.exception.button.UnknownDirectionException;
+import mimis.exception.worker.ActivateException;
+import mimis.input.Button;
+import mimis.value.Action;
+import de.hardcode.jxinput.event.JXInputButtonEvent;
+import de.hardcode.jxinput.event.JXInputDirectionalEvent;
+
+public class Extreme3DDevice extends JavaInputDevice {
+    protected static final String TITLE = "Extreme 3D";
+    protected static final String NAME = "Logitech Extreme 3D";
+
+    protected static Extreme3DTaskMapCycle taskMapCycle;
+
+    public Extreme3DDevice() {
+        super(TITLE, NAME);
+        taskMapCycle = new Extreme3DTaskMapCycle();
+    }
+
+    protected void activate() throws ActivateException {
+        super.activate();
+        parser(Action.ADD, taskMapCycle.mimis);
+        parser(Action.ADD, taskMapCycle.player);
+        parser(Action.ADD, taskMapCycle.like);
+    }
+
+    protected Button getButton(JXInputButtonEvent event) throws UnknownButtonException {
+        return Extreme3DButton.create(event);
+    }
+
+    protected Button getButton(JXInputDirectionalEvent event) throws UnknownDirectionException {
+        return DirectionButton.create(event);
+    }
+}

java/mimis/src/main/java/mimis/device/javainput/extreme3d/Extreme3DTaskMapCycle.java

@@ -0,0 +1,70 @@
+package mimis.device.javainput.extreme3d;
+
+import mimis.device.javainput.DirectionButton;
+import mimis.input.Task;
+import mimis.input.state.Press;
+import mimis.state.TaskMap;
+import mimis.state.TaskMapCycle;
+import mimis.value.Action;
+import mimis.value.Target;
+
+public class Extreme3DTaskMapCycle extends TaskMapCycle {
+    protected static final long serialVersionUID = 1L;
+
+    public TaskMap mimis, player, like;
+
+    public Extreme3DTaskMapCycle() {
+        /* Mimis */
+        mimis = new TaskMap();
+        mimis.add(
+            new Press(Extreme3DButton.SEVEN),
+            new Task(Action.PREVIOUS, Target.MAIN));
+        mimis.add(
+            new Press(Extreme3DButton.EIGHT),
+            new Task(Action.NEXT, Target.MAIN));
+        add(mimis);
+        
+        /* Player */
+        player = new TaskMap();
+        player.add(
+            new Press(Extreme3DButton.ONE),
+            new Task(Action.PLAY, Target.CURRENT));
+        player.add(
+            new Press(Extreme3DButton.TWO),
+            new Task(Action.MUTE, Target.CURRENT));
+        player.add(
+            new Press(Extreme3DButton.NINE),
+            new Task(Action.SHUFFLE, Target.CURRENT));
+        player.add(
+            new Press(Extreme3DButton.TEN),
+            new Task(Action.REPEAT, Target.CURRENT));
+        player.add(
+            new Press(Extreme3DButton.SIX),
+            new Task(Action.NEXT, Target.CURRENT));
+        player.add(
+            new Press(Extreme3DButton.FOUR),
+            new Task(Action.PREVIOUS, Target.CURRENT));        
+        player.add(
+            new Press(Extreme3DButton.FIVE),
+            new Task(Action.FORWARD, Target.CURRENT));
+        player.add(
+            new Press(Extreme3DButton.THREE),
+            new Task(Action.REWIND, Target.CURRENT));
+        player.add(
+            new Press(DirectionButton.SOUTH),
+            new Task(Action.VOLUME_DOWN, Target.CURRENT));
+        player.add(
+            new Press(DirectionButton.NORTH),
+            new Task(Action.VOLUME_UP, Target.CURRENT));        
+        add(player);
+
+        like = new TaskMap();
+        like.add(
+            new Press(Extreme3DButton.ELEVEN),
+            new Task(Action.LIKE, Target.CURRENT));
+        like.add(
+            new Press(Extreme3DButton.TWELVE),
+            new Task(Action.DISLIKE, Target.CURRENT));
+        add(like);
+    }
+}

java/mimis/src/main/java/mimis/device/javainput/rumblepad/RumblepadButton.java

@@ -0,0 +1,41 @@
+package mimis.device.javainput.rumblepad;
+
+import mimis.exception.button.UnknownButtonException;
+import mimis.input.Button;
+import de.hardcode.jxinput.event.JXInputButtonEvent;
+
+public enum RumblepadButton implements Button {
+    ONE    ("Button 0"),
+    TWO    ("Button 1"),
+    THREE  ("Button 2"),
+    FOUR   ("Button 3"),
+    FIVE   ("Button 4"),
+    SIX    ("Button 5"),
+    SEVEN  ("Button 6"),
+    EIGHT  ("Button 7"),
+    NINE   ("Button 8"),
+    TEN    ("Button 9");
+
+    protected String code;
+
+    private RumblepadButton(String code) {
+        this.code = code;
+    }
+
+    public String getCode() {
+        return code;
+    }
+
+    public static RumblepadButton create(String code) throws UnknownButtonException {
+        for (RumblepadButton button : RumblepadButton.values()) {
+            if (button.getCode().equals(code)) {
+                return button;
+            }
+        }
+        throw new UnknownButtonException();
+    }
+
+    public static RumblepadButton create(JXInputButtonEvent event) throws UnknownButtonException {
+        return create(event.getButton().getName());      
+    }
+}

java/mimis/src/main/java/mimis/device/javainput/rumblepad/RumblepadDevice.java

@@ -0,0 +1,38 @@
+package mimis.device.javainput.rumblepad;
+
+import mimis.device.javainput.DirectionButton;
+import mimis.device.javainput.JavaInputDevice;
+import mimis.exception.button.UnknownButtonException;
+import mimis.exception.button.UnknownDirectionException;
+import mimis.exception.worker.ActivateException;
+import mimis.input.Button;
+import mimis.value.Action;
+import de.hardcode.jxinput.event.JXInputButtonEvent;
+import de.hardcode.jxinput.event.JXInputDirectionalEvent;
+
+public class RumblepadDevice extends JavaInputDevice {
+    protected static final String TITLE = "RumblePad";
+    protected static final String NAME = "Logitech RumblePad 2 USB";
+
+    protected static RumblepadTaskMapCycle taskMapCycle;
+
+    public RumblepadDevice() {
+        super(TITLE, NAME);
+        taskMapCycle = new RumblepadTaskMapCycle(); 
+    }
+
+    protected void activate() throws ActivateException {
+        super.activate();
+        parser(Action.ADD, taskMapCycle.mimis);
+        parser(Action.ADD, taskMapCycle.player);
+        parser(Action.ADD, taskMapCycle.like);
+    }
+
+    protected Button getButton(JXInputButtonEvent event) throws UnknownButtonException {
+        return RumblepadButton.create(event);
+    }
+
+    protected Button getButton(JXInputDirectionalEvent event) throws UnknownDirectionException {
+        return DirectionButton.create(event);
+    }
+}

java/mimis/src/main/java/mimis/device/javainput/rumblepad/RumblepadTaskMapCycle.java

@@ -0,0 +1,70 @@
+package mimis.device.javainput.rumblepad;
+
+import mimis.device.javainput.DirectionButton;
+import mimis.input.Task;
+import mimis.input.state.Press;
+import mimis.state.TaskMap;
+import mimis.state.TaskMapCycle;
+import mimis.value.Action;
+import mimis.value.Target;
+
+public class RumblepadTaskMapCycle extends TaskMapCycle {
+    protected static final long serialVersionUID = 1L;
+
+    public TaskMap mimis, player, like;
+
+    public RumblepadTaskMapCycle() {
+        /* Mimis */
+        mimis = new TaskMap();
+        mimis.add(
+            new Press(RumblepadButton.ONE),
+            new Task(Action.PREVIOUS, Target.MAIN));
+        mimis.add(
+            new Press(RumblepadButton.THREE),
+            new Task(Action.NEXT, Target.MAIN));
+        add(mimis);
+        
+        /* Player */
+        player = new TaskMap();
+        player.add(
+            new Press(DirectionButton.WEST),
+            new Task(Action.PLAY, Target.CURRENT));
+        player.add(
+            new Press(DirectionButton.EAST),
+            new Task(Action.MUTE, Target.CURRENT));
+        player.add(
+            new Press(RumblepadButton.NINE),
+            new Task(Action.SHUFFLE, Target.CURRENT));
+        player.add(
+            new Press(RumblepadButton.TEN),
+            new Task(Action.REPEAT, Target.CURRENT));
+        player.add(
+            new Press(RumblepadButton.EIGHT),
+            new Task(Action.NEXT, Target.CURRENT));
+        player.add(
+            new Press(RumblepadButton.SIX),
+            new Task(Action.PREVIOUS, Target.CURRENT));    
+        player.add(
+            new Press(RumblepadButton.SEVEN),
+            new Task(Action.FORWARD, Target.CURRENT));
+        player.add(
+            new Press(RumblepadButton.FIVE),
+            new Task(Action.REWIND, Target.CURRENT));
+        player.add(
+            new Press(DirectionButton.SOUTH),
+            new Task(Action.VOLUME_DOWN, Target.CURRENT));
+        player.add(
+            new Press(DirectionButton.NORTH),
+            new Task(Action.VOLUME_UP, Target.CURRENT));
+        add(player);
+
+        like = new TaskMap();
+        like.add(
+            new Press(RumblepadButton.FOUR),
+            new Task(Action.LIKE, Target.CURRENT));
+        like.add(
+            new Press(RumblepadButton.TWO),
+            new Task(Action.DISLIKE, Target.CURRENT));
+        add(like);
+    }
+}

java/mimis/src/main/java/mimis/device/jintellitype/CommandButton.java

@@ -0,0 +1,74 @@
+package mimis.device.jintellitype;
+
+import mimis.exception.button.UnknownButtonException;
+import mimis.input.Button;
+
+import com.melloware.jintellitype.JIntellitype;
+
+
+public enum CommandButton implements Button {
+    BROWSER_BACKWARD       (JIntellitype.APPCOMMAND_BROWSER_BACKWARD),
+    BROWSER_FORWARD        (JIntellitype.APPCOMMAND_BROWSER_FORWARD),
+    BROWSER_REFRESH        (JIntellitype.APPCOMMAND_BROWSER_REFRESH),
+    BROWSER_STOP           (JIntellitype.APPCOMMAND_BROWSER_STOP),
+    BROWSER_SEARCH         (JIntellitype.APPCOMMAND_BROWSER_SEARCH),
+    BROWSER_FAVOURITES     (JIntellitype.APPCOMMAND_BROWSER_FAVOURITES),
+    BROWSER_HOME           (JIntellitype.APPCOMMAND_BROWSER_HOME),
+    VOLUME_MUTE            (JIntellitype.APPCOMMAND_VOLUME_MUTE),
+    VOLUME_DOWN            (JIntellitype.APPCOMMAND_VOLUME_DOWN),
+    VOLUME_UP              (JIntellitype.APPCOMMAND_VOLUME_UP),
+    MEDIA_NEXTTRACK        (JIntellitype.APPCOMMAND_MEDIA_NEXTTRACK),
+    MEDIA_PREVIOUSTRACK    (JIntellitype.APPCOMMAND_MEDIA_PREVIOUSTRACK),
+    MEDIA_STOP             (JIntellitype.APPCOMMAND_MEDIA_STOP),
+    MEDIA_PLAY_PAUSE       (JIntellitype.APPCOMMAND_MEDIA_PLAY_PAUSE),
+    LAUNCH_MAIL            (JIntellitype.APPCOMMAND_LAUNCH_MAIL),
+    LAUNCH_MEDIA_SELECT    (JIntellitype.APPCOMMAND_LAUNCH_MEDIA_SELECT),
+    LAUNCH_APP1            (JIntellitype.APPCOMMAND_LAUNCH_APP1),
+    LAUNCH_APP2            (JIntellitype.APPCOMMAND_LAUNCH_APP2),
+    BASS_DOWN              (JIntellitype.APPCOMMAND_BASS_DOWN),
+    BASS_BOOST             (JIntellitype.APPCOMMAND_BASS_BOOST),
+    BASS_UP                (JIntellitype.APPCOMMAND_BASS_UP),
+    TREBLE_DOWN            (JIntellitype.APPCOMMAND_TREBLE_DOWN),
+    TREBLE_UP              (JIntellitype.APPCOMMAND_TREBLE_UP),
+    MICROPHONE_VOLUME_MUTE (JIntellitype.APPCOMMAND_MICROPHONE_VOLUME_MUTE),
+    MICROPHONE_VOLUME_DOWN (JIntellitype.APPCOMMAND_MICROPHONE_VOLUME_DOWN),
+    MICROPHONE_VOLUME_UP   (JIntellitype.APPCOMMAND_MICROPHONE_VOLUME_UP),
+    HELP                   (JIntellitype.APPCOMMAND_HELP),
+    FIND                   (JIntellitype.APPCOMMAND_FIND),
+    NEW                    (JIntellitype.APPCOMMAND_NEW),
+    OPEN                   (JIntellitype.APPCOMMAND_OPEN),
+    CLOSE                  (JIntellitype.APPCOMMAND_CLOSE),
+    SAVE                   (JIntellitype.APPCOMMAND_SAVE),
+    PRINT                  (JIntellitype.APPCOMMAND_PRINT),
+    UNDO                   (JIntellitype.APPCOMMAND_UNDO),
+    REDO                   (JIntellitype.APPCOMMAND_REDO),
+    COPY                   (JIntellitype.APPCOMMAND_COPY),
+    CUT                    (JIntellitype.APPCOMMAND_CUT),
+    PASTE                  (JIntellitype.APPCOMMAND_PASTE),
+    REPLY_TO_MAIL          (JIntellitype.APPCOMMAND_REPLY_TO_MAIL),
+    FORWARD_MAIL           (JIntellitype.APPCOMMAND_FORWARD_MAIL),
+    SEND_MAIL              (JIntellitype.APPCOMMAND_SEND_MAIL),
+    SPELL_CHECK            (JIntellitype.APPCOMMAND_SPELL_CHECK),
+    DICTATE_OR_COMMAND_CONTROL_TOGGLE (JIntellitype.APPCOMMAND_DICTATE_OR_COMMAND_CONTROL_TOGGLE),
+    MIC_ON_OFF_TOGGLE      (JIntellitype.APPCOMMAND_MIC_ON_OFF_TOGGLE),
+    CORRECTION_LIST        (JIntellitype.APPCOMMAND_CORRECTION_LIST);
+
+    protected int code;
+
+    private CommandButton(int code) {
+        this.code = code;
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public static CommandButton create(int code) throws UnknownButtonException {
+        for (CommandButton button : CommandButton.values()) {
+            if (button.getCode() == code) {
+                return button;
+            }
+        }
+        throw new UnknownButtonException();
+    }
+}

java/mimis/src/main/java/mimis/device/jintellitype/Hotkey.java

@@ -0,0 +1,46 @@
+package mimis.device.jintellitype;
+
+import java.util.ArrayList;
+
+import mimis.input.Button;
+import mimis.value.Key;
+
+import com.melloware.jintellitype.JIntellitype;
+
+public class Hotkey implements Button {
+    protected static final long serialVersionUID = 1L;
+
+    protected static ArrayList<Hotkey> hotkeyList;
+    protected static JIntellitype jit;
+
+    public Hotkey(int modifier, int keycode) {
+        int id = hotkeyList.size();
+        jit.registerHotKey(id, modifier, keycode);
+        hotkeyList.add(this);
+    }
+
+    public Hotkey(int modifier, char character) {
+        this(modifier, (int) Character.toUpperCase(character));
+    }
+
+    public Hotkey(char character) {
+        this(0, (int) Character.toUpperCase(character));
+    }
+
+    public Hotkey(int keycode) {
+        this(0, keycode);
+    }
+
+    public Hotkey(Key key) {
+        this(key.getCode());
+    }
+
+    public Hotkey(int modifier, Key key) {
+        this(modifier, key.getCode());
+    }
+
+    public static void initialise(ArrayList<Hotkey> actionList, JIntellitype jit) {
+        Hotkey.hotkeyList = actionList;
+        Hotkey.jit = jit;
+    }
+}

java/mimis/src/main/java/mimis/device/jintellitype/JIntellitypeDevice.java

@@ -0,0 +1,71 @@
+package mimis.device.jintellitype;
+
+import java.util.ArrayList;
+
+import mimis.device.Device;
+import mimis.exception.button.UnknownButtonException;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.input.state.Press;
+import mimis.input.state.Release;
+import mimis.value.Action;
+import mimis.worker.Component;
+
+import com.melloware.jintellitype.HotkeyListener;
+import com.melloware.jintellitype.IntellitypeListener;
+import com.melloware.jintellitype.JIntellitype;
+
+public class JIntellitypeDevice extends Component implements Device, HotkeyListener, IntellitypeListener {
+    protected static final String TITLE = "Keyboard";
+
+    protected JIntellitypeTaskMapCycle taskMapCycle;
+    protected ArrayList<Hotkey> hotkeyList;
+    protected JIntellitype jit;
+
+    public JIntellitypeDevice() {
+        super(TITLE);
+        hotkeyList = new ArrayList<Hotkey>();
+        jit = JIntellitype.getInstance();
+        Hotkey.initialise(hotkeyList, jit);
+        taskMapCycle = new JIntellitypeTaskMapCycle();
+    }
+
+    protected void activate() throws ActivateException {
+        super.activate();
+        jit.addHotKeyListener(this);
+        jit.addIntellitypeListener(this);
+        parser(Action.ADD, taskMapCycle.mimis);
+        parser(Action.ADD, taskMapCycle.player);
+    }
+
+    public void onIntellitype(int command) {
+        if (active) {
+            try {
+            CommandButton commandButton = CommandButton.create(command);
+            route(new Press(commandButton));
+            route(new Release(commandButton));
+            } catch (UnknownButtonException e) {
+                log.error(e);
+            }
+        }
+    }
+
+    public void onHotKey(int id) {
+        if (active) {
+            Hotkey hotkey = hotkeyList.get(id);
+            route(new Press(hotkey));
+            route(new Release(hotkey));
+        }
+    }
+
+    protected void deactivate() throws DeactivateException {
+        super.deactivate();
+        jit.removeHotKeyListener(this);
+        jit.removeIntellitypeListener(this);
+    }
+
+    public void exit() {
+        super.exit();
+        jit.cleanUp();
+    }
+}

java/mimis/src/main/java/mimis/device/jintellitype/JIntellitypeTaskMapCycle.java

@@ -0,0 +1,45 @@
+package mimis.device.jintellitype;
+
+import mimis.input.Task;
+import mimis.state.TaskMap;
+import mimis.state.TaskMapCycle;
+import mimis.value.Action;
+import mimis.value.Key;
+import mimis.value.Target;
+
+public class JIntellitypeTaskMapCycle extends TaskMapCycle {
+    protected static final long serialVersionUID = 1L;
+    
+    public TaskMap mimis, player;
+    
+    public JIntellitypeTaskMapCycle() {
+        /* Mimis */
+        mimis = new TaskMap();
+        mimis.add(
+            new Hotkey(Key.PRIOR),
+            new Task(Action.PREVIOUS, Target.MAIN));
+        mimis.add(
+            new Hotkey(Key.NEXT),
+            new Task(Action.NEXT, Target.MAIN));
+        add(mimis);
+        
+        /* Player */
+        player = new TaskMap();
+        player.add(
+            CommandButton.VOLUME_DOWN,
+            new Task(Action.VOLUME_DOWN, Target.APPLICATIONS));
+        player.add(
+            CommandButton.VOLUME_UP,
+            new Task(Action.VOLUME_UP, Target.APPLICATIONS));
+        player.add(
+            new Hotkey(Modifier.CTRL | Modifier.WIN, 'x'),
+            new Task(Action.EXIT, Target.MAIN));
+        player.add(
+            new Hotkey(Modifier.CTRL | Modifier.SHIFT | Modifier.WIN, 'n'),
+            new Task(Action.NEXT, Target.CURRENT));
+        player.add(
+            new Hotkey(Modifier.CTRL | Modifier.SHIFT | Modifier.WIN, 'p'),
+            new Task(Action.PREVIOUS, Target.CURRENT));
+        add(player);
+    }
+}

java/mimis/src/main/java/mimis/device/jintellitype/Modifier.java

@@ -0,0 +1,25 @@
+package mimis.device.jintellitype;
+
+import mimis.input.Button;
+
+import com.melloware.jintellitype.JIntellitype;
+
+public class Modifier implements Button {
+    protected static final long serialVersionUID = 1L;
+
+    public static final int
+        ALT = JIntellitype.MOD_ALT,
+        CTRL = JIntellitype.MOD_CONTROL,
+        SHIFT = JIntellitype.MOD_SHIFT,
+        WIN = JIntellitype.MOD_WIN;
+
+    protected int code;
+
+    protected Modifier(int code) {
+        this.code = code;
+    }
+
+    public int getCode() {
+        return code;
+    }
+}

java/mimis/src/main/java/mimis/device/lirc/LircButton.java

@@ -0,0 +1,10 @@
+package mimis.device.lirc;
+
+import mimis.input.Button;
+
+public interface LircButton extends Button {
+    public static final String NAME = null;
+
+    public String getCode();
+    public String getName();
+}

java/mimis/src/main/java/mimis/device/lirc/LircButtonListener.java

@@ -0,0 +1,5 @@
+package mimis.device.lirc;
+
+public interface LircButtonListener {
+    public void add(LircButton lircButton);
+}

java/mimis/src/main/java/mimis/device/lirc/LircDevice.java

@@ -0,0 +1,108 @@
+package mimis.device.lirc;
+
+import mimis.application.cmd.CMDApplication;
+import mimis.device.Device;
+import mimis.device.lirc.remote.DenonRC176Button;
+import mimis.device.lirc.remote.PhiliphsRCLE011Button;
+import mimis.device.lirc.remote.SamsungBN5901015AButton;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.input.Button;
+import mimis.input.button.ColorButton;
+import mimis.input.button.NumberButton;
+import mimis.input.state.Press;
+import mimis.input.state.Release;
+import mimis.util.Multiplexer;
+import mimis.util.Native;
+import mimis.util.multiplexer.SignalListener;
+import mimis.value.Action;
+import mimis.value.Signal;
+
+public class LircDevice extends CMDApplication implements Device, LircButtonListener, SignalListener<Button> {
+    protected final static String PROGRAM = "winlirc.exe";
+    protected static final String TITLE = "Lirc";
+
+    protected Multiplexer<Button> multiplexer;
+    protected LircService lircService;
+    protected LircTaskMapCycle taskMapCycle;
+
+    public LircDevice() {
+        super(PROGRAM, TITLE);
+        multiplexer = new Multiplexer<Button>(this);
+        lircService = new LircService();
+        lircService.put(PhiliphsRCLE011Button.NAME, PhiliphsRCLE011Button.values());
+        lircService.put(DenonRC176Button.NAME, DenonRC176Button.values());
+        lircService.put(SamsungBN5901015AButton.NAME, SamsungBN5901015AButton.values());
+        lircService.add(this);
+        taskMapCycle = new LircTaskMapCycle();
+    }
+
+    protected void activate() throws ActivateException {
+        super.activate();
+        lircService.start();
+        parser(Action.ADD, taskMapCycle.denonRC176);
+        parser(Action.ADD, taskMapCycle.philiphsRCLE011);
+        parser(Action.ADD, taskMapCycle.samsungBN5901015A);
+    }
+
+    public boolean active() {
+        if (detect) {
+            if (active && !lircService.active()) {
+                stop();
+            } else if (!active) {
+                running = Native.isRunning(PROGRAM);
+                if (running) {
+                    start();
+                }
+            }
+        }
+        return active;
+    }
+
+    protected void deactivate() throws DeactivateException {
+        log.debug("Deactivate LircDevice");
+        super.deactivate();
+        lircService.stop();
+        multiplexer.stop();
+    }
+
+    public void exit() {
+        log.debug("Exit LircDevice");
+        super.exit();
+        lircService.exit();
+        multiplexer.exit();
+    }
+
+    public void add(LircButton lircButton) {
+        multiplexer.add(lircButton);
+    }
+
+    public void add(Signal signal, Button button) {
+        add(signal, button, true);
+    }
+
+    public void add(Signal signal, Button button, boolean general) {
+        switch (signal) {
+            case BEGIN:
+                route(new Press(button));
+                break;
+            case END:
+                route(new Release(button));
+                break;
+        }
+
+        if (general) {
+            String string = button.toString();
+            for (Button colorButton : ColorButton.values()) {
+                if (colorButton.toString().equals(string)) {
+                    add(signal, ColorButton.valueOf(string), false);
+                }
+            }
+            for (Button numberButton : NumberButton.values()) {
+                if (numberButton.toString().equals(string)) {
+                    add(signal, NumberButton.valueOf(string), false);
+                }
+            }
+        }
+    }    
+}

java/mimis/src/main/java/mimis/device/lirc/LircService.java

@@ -0,0 +1,160 @@
+package mimis.device.lirc;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.net.Socket;
+import java.net.SocketTimeoutException;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.InputMismatchException;
+import java.util.NoSuchElementException;
+import java.util.Scanner;
+
+import mimis.exception.button.UnknownButtonException;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.util.Native;
+import mimis.value.Registry;
+import mimis.worker.Worker;
+
+public class LircService extends Worker {
+    public static final String IP = "localhost";
+    public static final int PORT = 8765;
+
+    protected ArrayList<LircButtonListener> lircButtonListenerList;
+    protected String ip;
+    protected int port;
+    protected Socket socket;
+    protected InputStream inputStream;
+    protected OutputStream outputStream;
+    protected BufferedReader bufferedReader;
+    protected PrintWriter printWriter;
+    protected HashMap<String, LircButton[]> buttonMap;
+    protected String send;
+
+    public LircService() {
+        this(IP, PORT);
+        buttonMap = new HashMap<String, LircButton[]>();
+        send = Native.getValue(Registry.CURRENT_USER, "Software\\LIRC", "password");
+    }
+
+    public LircService(String ip, int port) {
+        this.ip = ip;
+        this.port = port;
+        lircButtonListenerList = new ArrayList<LircButtonListener>();
+    }
+
+    public void put(String name, LircButton[] LircButtonArray) {
+        buttonMap.put(name, LircButtonArray);
+    }
+
+    public void add(LircButtonListener lircButtonListener) {
+        lircButtonListenerList.add(lircButtonListener);
+    }
+
+    public void remove(LircButtonListener lircButtonListener) {
+        lircButtonListenerList.remove(lircButtonListener);
+    }
+
+    public void activate() throws ActivateException {
+        log.trace("Activate LircService");
+        try {
+            socket = new Socket(ip, port);
+            socket.setSoTimeout(SLEEP);
+
+            inputStream = socket.getInputStream();
+            bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
+
+            outputStream = socket.getOutputStream();
+            printWriter = new PrintWriter(outputStream);
+        } catch (UnknownHostException e) {
+            log.error(e);
+            throw new ActivateException();
+        } catch (IOException e) {
+            log.error(e);
+            throw new ActivateException();
+        }
+        super.activate();
+    }
+
+    public synchronized boolean active() {
+        if (active && !socket.isConnected()) {
+            active = false;
+        }
+        return active;
+    }
+
+    public void deactivate() throws DeactivateException {
+        log.trace("Deactivate LircService");
+        super.deactivate();
+        try {
+            inputStream.close();
+            outputStream.close();
+            socket.close();
+        } catch (IOException e) {
+            log.error(e);
+        }
+    }
+
+    public void work() {
+        try {
+            String line = bufferedReader.readLine();
+            while (line.equals("BEGIN")) {
+                while (!bufferedReader.readLine().equals("END"));
+                line = bufferedReader.readLine();
+            }
+            try {
+                LircButton lircButton = parseButton(new Scanner(line));
+                for (LircButtonListener lircbuttonListener : lircButtonListenerList) {
+                    lircbuttonListener.add(lircButton);
+                }
+            } catch (UnknownButtonException e) {
+                log.error(e);
+            }
+        } catch (SocketTimeoutException e) {
+        } catch (IOException e) {
+            log.error(e);
+        }
+    }
+
+    public LircButton parseButton(Scanner scanner) throws UnknownButtonException {
+        try {
+            scanner.next();
+            scanner.next();
+            String code = scanner.next();
+            String remote = scanner.next();
+            log.trace(String.format("%s: %s", remote, code));
+            LircButton[] buttonArray = buttonMap.get(remote);
+            if (buttonArray != null) {            
+                for (LircButton button : buttonArray) {
+                    if (button.getCode().equals(code)) {
+                        return button;
+                    }
+                }
+            }
+        } catch (InputMismatchException e) {
+            log.error(e);
+        } catch (NoSuchElementException e) {
+            log.error(e);
+        }
+        throw new UnknownButtonException();
+    }
+
+    public void send(LircButton button) {
+        send(button, 0);
+    }
+
+    public void send(LircButton button, int repeat) {
+        if (send == null) {
+            return;
+        }
+        String command = String.format("%s %s %s \n", send, button.getName(), button.getCode());
+        printWriter.append(command);
+        printWriter.flush();
+    }
+}

java/mimis/src/main/java/mimis/device/lirc/LircTaskMapCycle.java

@@ -0,0 +1,19 @@
+package mimis.device.lirc;
+
+import mimis.device.lirc.remote.DenonRC176EventMap;
+import mimis.device.lirc.remote.PhiliphsRCLE011EventMap;
+import mimis.device.lirc.remote.SamsungBN5901015AEventMap;
+import mimis.state.TaskMap;
+import mimis.state.TaskMapCycle;
+
+public class LircTaskMapCycle extends TaskMapCycle {
+    protected static final long serialVersionUID = 1L;
+
+    public TaskMap denonRC176, philiphsRCLE011, samsungBN5901015A;
+
+    public LircTaskMapCycle() {      
+        add(denonRC176 = new DenonRC176EventMap());
+        add(philiphsRCLE011 = new PhiliphsRCLE011EventMap());
+        add(samsungBN5901015A = new SamsungBN5901015AEventMap());
+    }
+}

java/mimis/src/main/java/mimis/device/lirc/remote/DenonRC176Button.java

@@ -0,0 +1,50 @@
+package mimis.device.lirc.remote;
+
+import mimis.device.lirc.LircButton;
+
+public enum DenonRC176Button implements LircButton {
+    TAPE_AB ("TAPE_AB"),
+    TAPE_REC ("TAPE_REC"),
+    TAPE_PAUSE ("TAPE_PAUSE"),
+    TAPE_STOP ("TAPE_STOP"),
+    TAPE_REWIND ("TAPE_REW"),
+    TAPE_FORWARD ("TAPE_FF"),
+    TAPE_PREIVOUS ("TAPE_PLAYREV"),
+    TAPE_NEXT ("TAPE_PLAY"),
+    CD_PREVIOUS ("CD_TRACK_-"),
+    CD_NEXT ("CD_TRACK_+"),
+    CD_SHUFFLE ("CD_RANDOM"),
+    CD_REPEAT ("CD_REPEAT"),
+    CD_SKIP ("CD_SKIP"),
+    CD_PAUSE ("CD_PAUSE"),
+    CD_STOP ("CD_STOP"),
+    CD_PLAY ("CD_PLAY"),
+    AMP_TAPE2 ("AMP_TAPE2"),
+    AMP_TAPE1 ("AMP_TAPE1"),
+    AMP_AUX ("AMP_AUX"),
+    AMP_TUNER ("AMP_TUNER"),
+    AMP_CD ("AMP_CD"),
+    AMP_PHONO ("AMP_PHONO"),
+    AMP_VOLUME_UP ("AMP_VOL_UP"),
+    AMP_VOLUME_DOWN ("AMP_VOL_DOWN"),
+    AMP_POWER ("AMP_POWER"),
+    AMP_MUTE ("AMP_MUTE"),
+    TUNER_UP ("TUN_CH_UP"),
+    TUNER_DOWN ("TUN_CH_DOWN");    
+
+    public static final String NAME = "DENON_RC-176";
+
+    protected String code;
+
+    private DenonRC176Button(String code) {
+        this.code = code;
+    }
+
+    public String getCode() {
+        return code;
+    }
+
+    public String getName() {
+        return NAME;
+    }
+}

java/mimis/src/main/java/mimis/device/lirc/remote/DenonRC176EventMap.java

@@ -0,0 +1,32 @@
+package mimis.device.lirc.remote;
+
+import mimis.input.Task;
+import mimis.state.TaskMap;
+import mimis.value.Action;
+import mimis.value.Target;
+
+public class DenonRC176EventMap extends TaskMap {
+    protected static final long serialVersionUID = 1L;
+    
+    public DenonRC176EventMap() {
+        /* Mimis */
+        add(DenonRC176Button.TUNER_UP, new Task(Action.NEXT, Target.MAIN));
+        add(DenonRC176Button.TUNER_DOWN, new Task(Action.PREVIOUS, Target.MAIN));
+
+        /* Application */
+        add(DenonRC176Button.AMP_POWER, new Task(Action.START, Target.CURRENT));
+        add(DenonRC176Button.CD_NEXT, new Task(Action.NEXT, Target.CURRENT));
+        add(DenonRC176Button.CD_PREVIOUS, new Task(Action.PREVIOUS, Target.CURRENT));
+        add(DenonRC176Button.TAPE_REWIND, new Task(Action.REWIND, Target.CURRENT));
+        add(DenonRC176Button.CD_PLAY, new Task(Action.PLAY, Target.CURRENT));
+        add(DenonRC176Button.CD_PAUSE, new Task(Action.PLAY, Target.CURRENT));
+        add(DenonRC176Button.TAPE_FORWARD, new Task(Action.FORWARD, Target.CURRENT));
+        add(DenonRC176Button.AMP_MUTE, new Task(Action.MUTE, Target.CURRENT));
+        add(DenonRC176Button.AMP_VOLUME_UP, new Task(Action.VOLUME_UP, Target.CURRENT));
+        add(DenonRC176Button.AMP_VOLUME_DOWN, new Task(Action.VOLUME_DOWN, Target.CURRENT));
+        add(DenonRC176Button.CD_REPEAT, new Task(Action.REPEAT, Target.CURRENT));
+        add(DenonRC176Button.CD_SHUFFLE, new Task(Action.SHUFFLE, Target.CURRENT));
+        add(DenonRC176Button.TAPE_AB, new Task(Action.LIKE, Target.CURRENT));
+        add(DenonRC176Button.TAPE_REC, new Task(Action.DISLIKE, Target.CURRENT));
+    }
+}

java/mimis/src/main/java/mimis/device/lirc/remote/PhiliphsRCLE011Button.java

@@ -0,0 +1,57 @@
+package mimis.device.lirc.remote;
+
+import mimis.device.lirc.LircButton;
+
+public enum PhiliphsRCLE011Button implements LircButton {
+    POWER ("Standby"),
+    RED ("Red"),
+    GREEN ("Green"),
+    YELLOW ("Yellow"),
+    BLUE ("Blue"),
+    TUNE ("Tune"),
+    RADIO ("Radio"),
+    SQUARE ("Square"),
+    MENU ("Menu"),
+    TEXT ("Text"),
+    UP ("Up"),
+    DOWN ("Down"),
+    LEFT ("Left"),
+    RIGHT ("Right"),
+    VOLUME_UP ("Volume+"),
+    VOLUME_DOWN ("Volume-"),
+    MUTE ("Mute"),
+    PROGRAM_UP ("Program+"),
+    PROGRAM_DOWN ("Program-"),
+    ONE ("1"),
+    TWO ("2"),
+    THREE ("3"),
+    FOUR ("4"),
+    FIVE ("5"),
+    SIX ("6"),
+    SEVEN ("7"),
+    EIGHT ("8"),
+    NINE ("9"),
+    ZERO ("0"),
+    CLOCK ("Clock"),
+    OUT ("Out"),
+    INFO ("i+"),
+    SCREEN_UP ("screenup"),
+    SCREEN_DOWN ("screendown"),
+    QUESTION ("question");
+
+    public static final String NAME = "Philips_RCLE011";
+
+    protected String code;
+
+    private PhiliphsRCLE011Button(String code) {
+        this.code = code;
+    }
+
+    public String getCode() {
+        return code;
+    }
+
+    public String getName() {
+        return NAME;
+    }
+}

java/mimis/src/main/java/mimis/device/lirc/remote/PhiliphsRCLE011EventMap.java

@@ -0,0 +1,32 @@
+package mimis.device.lirc.remote;
+
+import mimis.input.Task;
+import mimis.state.TaskMap;
+import mimis.value.Action;
+import mimis.value.Target;
+
+public class PhiliphsRCLE011EventMap extends TaskMap {
+    protected static final long serialVersionUID = 1L;
+    
+    public PhiliphsRCLE011EventMap() {
+        /* Mimis */
+        add(PhiliphsRCLE011Button.UP, new Task(Action.NEXT, Target.MAIN));
+        add(PhiliphsRCLE011Button.DOWN, new Task(Action.PREVIOUS, Target.MAIN));
+
+        /* Application */
+        add(PhiliphsRCLE011Button.POWER, new Task(Action.START, Target.CURRENT));
+        add(PhiliphsRCLE011Button.PROGRAM_UP, new Task(Action.NEXT, Target.CURRENT));
+        add(PhiliphsRCLE011Button.PROGRAM_DOWN, new Task(Action.PREVIOUS, Target.CURRENT));
+        add(PhiliphsRCLE011Button.LEFT, new Task(Action.REWIND, Target.CURRENT));
+        add(PhiliphsRCLE011Button.TUNE, new Task(Action.PLAY, Target.CURRENT));
+        add(PhiliphsRCLE011Button.RIGHT, new Task(Action.FORWARD, Target.CURRENT));
+        add(PhiliphsRCLE011Button.VOLUME_DOWN, new Task(Action.VOLUME_DOWN, Target.CURRENT));
+        add(PhiliphsRCLE011Button.MUTE, new Task(Action.MUTE, Target.CURRENT));
+        add(PhiliphsRCLE011Button.VOLUME_UP, new Task(Action.VOLUME_UP, Target.CURRENT));
+        add(PhiliphsRCLE011Button.CLOCK, new Task(Action.REPEAT, Target.CURRENT));
+        add(PhiliphsRCLE011Button.OUT, new Task(Action.SHUFFLE, Target.CURRENT));
+        add(PhiliphsRCLE011Button.SQUARE, new Task(Action.FULLSCREEN, Target.CURRENT));
+        add(PhiliphsRCLE011Button.RED, new Task(Action.DISLIKE, Target.CURRENT));
+        add(PhiliphsRCLE011Button.GREEN, new Task(Action.LIKE, Target.CURRENT));
+    }
+}

java/mimis/src/main/java/mimis/device/lirc/remote/SamsungBN5901015AButton.java

@@ -0,0 +1,70 @@
+package mimis.device.lirc.remote;
+
+import mimis.device.lirc.LircButton;
+
+public enum SamsungBN5901015AButton implements LircButton {
+    POWER ("Power"),
+    SOURCE ("Source"),
+    ONE ("1"),
+    TWO ("2"),
+    THREE ("3"),
+    FOUR ("4"),
+    FIVE ("5"),
+    SIX ("6"),
+    SEVEN ("7"),
+    EIGHT ("8"),
+    NINE ("9"),
+    ZERO ("0"),
+    TEXT ("TTX/Mix"),
+    CHANNEL_TOGGLE ("Pre-Ch"),
+    VOLUME_DOWN ("Vol+"),
+    VOLUME_UP ("Vol-"),
+    MUTE ("Mute"),
+    CHANNEL_LIST ("Ch.List"),
+    CHANNEL_NEXT ("Ch+"),
+    CHANNEL_PREVIOUS ("Ch-"),
+    MEDIA ("Media.P"),
+    MENU ("Menu"),
+    GUIDE ("Guide"),
+    TOOLS ("Tools"),
+    UP ("Up"),
+    INFO ("Info"),
+    RETURN ("Return"),
+    EXIT ("Exit"),
+    LEFT ("Left"),
+    ENTER ("Enter"),
+    RIGHT ("Right"),
+    DOWN ("Down"),
+    RED ("Red"),
+    GREEN ("Green"),
+    YELLOW ("Yellow"),
+    BLUE ("Blue"),
+    MODE_P ("P.Mode"),
+    MODE_S ("S.Mode"),
+    SIZE_P ("P.Size"),
+    Dual ("Dual"),
+    AUDIO ("AD"),
+    SUBTITLE ("Subt."),
+    REWIND ("Rewind"),
+    PAUSE ("Pause"),
+    FORWARD ("Forward"),
+    RECORD ("Record"),
+    PLAY ("Play"),
+    STOP ("Stop");
+
+    public static final String NAME = "Samsung_BN59-01015A";
+
+    protected String code;
+
+    private SamsungBN5901015AButton(String code) {
+        this.code = code;
+    }
+
+    public String getCode() {
+        return code;
+    }
+    
+    public String getName() {
+        return NAME;
+    }
+}

java/mimis/src/main/java/mimis/device/lirc/remote/SamsungBN5901015AEventMap.java

@@ -0,0 +1,14 @@
+package mimis.device.lirc.remote;
+
+import mimis.input.Task;
+import mimis.state.TaskMap;
+import mimis.value.Action;
+import mimis.value.Target;
+
+public class SamsungBN5901015AEventMap extends TaskMap {
+    protected static final long serialVersionUID = 1L;
+
+    public SamsungBN5901015AEventMap() {
+        add(SamsungBN5901015AButton.VOLUME_UP, new Task(Action.VOLUME_UP, Target.CURRENT));
+    }
+}

java/mimis/src/main/java/mimis/device/lirc/remote/WC02IPOButton.java

@@ -0,0 +1,28 @@
+package mimis.device.lirc.remote;
+
+import mimis.device.lirc.LircButton;
+
+public enum WC02IPOButton implements LircButton {
+    MINUS ("MINUS"),
+    PLUS ("PLUS"),
+    NEXT ("NEXT"),
+    PREVIOUS ("PREVIOUS"),
+    PLAY ("PLAY"),
+    HOLD ("HOLD");
+
+    public static final String NAME = "WC02-IPO";
+
+    protected String code;
+
+    private WC02IPOButton(String code) {
+        this.code = code;
+    }
+
+    public String getCode() {
+        return code;
+    }
+    
+    public String getName() {
+        return NAME;
+    }
+}

java/mimis/src/main/java/mimis/device/network/NetworkDevice.java

@@ -0,0 +1,189 @@
+package mimis.device.network;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+import mimis.device.Device;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.input.Feedback;
+import mimis.input.Input;
+import mimis.input.Task;
+import mimis.value.Action;
+import mimis.value.Target;
+import mimis.worker.Component;
+import mimis.worker.Worker;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+public class NetworkDevice extends Component implements Device {
+    protected static final String TITLE = "Network";
+    public static final int PORT = 6789;
+
+    protected Log log = LogFactory.getLog(NetworkDevice.class);
+    protected Server server;
+    protected ConcurrentLinkedQueue<Client> clientList;
+
+    public NetworkDevice(int port) {
+        super(TITLE);
+        clientList = new ConcurrentLinkedQueue<Client>();
+        server = new Server(port);
+    }
+
+    public NetworkDevice() {
+        this(PORT);
+    }
+
+    protected void activate() throws ActivateException {
+        server.start();
+        super.activate();
+    }
+
+    public boolean active() {
+        for (Client client : clientList) {
+            if (!client.active()) {
+                client.stop();
+            }
+        }
+        return active = server.active();
+    }
+
+    protected void deactivate() throws DeactivateException {
+        super.deactivate();
+        server.stop();
+    }
+
+    public synchronized void exit() {
+        super.exit();
+        server.exit();
+    }
+
+    protected void feedback(Feedback feedback) {
+        for (Client client : clientList) {
+            client.send(feedback);
+        }
+    }
+
+    protected class Server extends Worker {
+        protected ServerSocket serverSocket;
+        protected int port;
+        
+        public Server(int port) {
+            this.port = port;
+        }
+
+        protected void activate() throws ActivateException {
+            try {
+                serverSocket = new ServerSocket(port);
+            } catch (IOException e) {
+                throw new ActivateException();
+            }
+            super.activate();
+        }
+
+        public synchronized boolean active() {
+            return active = serverSocket != null && !serverSocket.isClosed();
+        }
+    
+        protected synchronized void deactivate() throws DeactivateException {
+            super.deactivate();
+            try {
+                route(new Feedback("[NetworkDevice] Closing server socket"));
+                serverSocket.close();
+            } catch (IOException e) {
+                log.error(e);
+            } finally {
+                for (Client client : clientList) {
+                    client.stop();
+                }
+            }
+        }
+    
+        public void work() {
+            try {
+                route(new Feedback("[NetworkDevice] Wating for clients"));
+                Socket socket = serverSocket.accept();
+                Client client = new Client(socket);
+                client.start();
+                route(new Feedback("[NetworkDevice] Client connected: " + socket.getInetAddress()));
+            } catch (IOException e) {
+                log.error(e);
+            }
+        }
+
+        public synchronized void exit() {
+            super.exit();
+            for (Client client : clientList) {
+                client.exit();
+            }
+        }
+    }
+
+    protected class Client extends Worker {
+        protected Socket socket;
+        protected InputStream inputStream;
+        protected OutputStream outputStream;
+        protected ObjectOutputStream objectOutputStream;
+
+        public Client(Socket socket) throws IOException {
+            this.socket = socket;
+            inputStream = socket.getInputStream();
+            outputStream = socket.getOutputStream();
+            objectOutputStream = new ObjectOutputStream(outputStream);
+            clientList.add(this);
+        }
+
+        public boolean active() {
+            return active = socket.isConnected();
+        }
+
+        public void work() {
+            ObjectInputStream objectInputStream;
+            try {
+                objectInputStream = new ObjectInputStream(inputStream);
+                Object object;
+                do {
+                    object = objectInputStream.readObject();
+                    if (object instanceof Input) {
+                        log.trace(object);
+                        route((Input) object);
+                    }
+                } while (object != null);
+            } catch (IOException e) {
+                log.error(e);
+                stop();
+            } catch (ClassNotFoundException e) {
+                log.error(e);
+            }
+        }
+
+        protected void deactivate() throws DeactivateException {
+            super.deactivate();
+            send(new Task(Action.STOP, Target.SELF));
+            clientList.remove(this);
+            try {
+                inputStream.close();
+                outputStream.close();
+                socket.close();    
+            } catch (IOException e) {
+                log.error(e);
+            }
+            route(new Feedback("[NetworkDevice] Client disconnected: " + socket.getInetAddress()));
+        }
+
+        public void send(Object object) {
+            try {
+                objectOutputStream.writeObject(object);
+            } catch (IOException e) {
+                log.error(e);
+            }
+        }
+    }
+}

java/mimis/src/main/java/mimis/device/panel/Panel.java

@@ -0,0 +1,180 @@
+package mimis.device.panel;
+
+import java.awt.BorderLayout;
+import java.awt.event.WindowEvent;
+
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.WindowConstants;
+
+import mimis.Gui;
+import mimis.util.Swing;
+import mimis.util.swing.HoldButton;
+import mimis.util.swing.HoldButtonListener;
+import mimis.util.swing.ToggleButton;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+public class Panel extends JFrame implements HoldButtonListener {
+    protected static final long serialVersionUID = 1L;
+    protected Log log = LogFactory.getLog(getClass());
+    protected final static String TITLE = "MIMIS Panel Device";
+
+    protected PanelDevice panelDevice;
+
+    protected HoldButton upButton;
+    protected HoldButton previousButton;
+    protected HoldButton rewindButton;
+    protected HoldButton stopButton;
+    protected ToggleButton playPauseToggleButton;
+    protected HoldButton forwardButton;
+    protected HoldButton downButton;
+    protected HoldButton nextButton;
+    protected HoldButton volumeDownButton;
+    protected ToggleButton muteToggleButton;
+    protected HoldButton volumeUpButton;
+    protected HoldButton repeatButton;
+    protected HoldButton shuffleButton;
+
+    Panel(PanelDevice panelDevice) {
+        super(TITLE);
+        this.panelDevice = panelDevice;
+        setIconImage(Swing.getImage(Gui.ICON));
+        createControls();
+        layoutControls();
+        pack();
+        setResizable(false);
+        setVisible(true);
+        setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+    }
+
+    protected HoldButton getButton(String name, String text) {
+        HoldButton button = new HoldButton(this);
+        button.setIcon(Swing.getImageIcon(name));
+        button.setToolTipText(text);
+        button.setFocusPainted(false);
+        return button;
+    }
+
+    protected ToggleButton getToggleButton(String firstName, String secondName, String text) {
+        ImageIcon firstImageIcon = Swing.getImageIcon(firstName);
+        ImageIcon secondImageIcon = Swing.getImageIcon(secondName);
+        ToggleButton button = new ToggleButton(this, firstImageIcon, secondImageIcon);
+        button.setToolTipText(text);
+        button.setFocusPainted(false);
+        return button;
+    }
+
+    protected void createControls() {
+        upButton = getButton("icons/up.png", "Go to previous application");
+        nextButton = getButton("icons/next.png", "Go to next track");
+        previousButton = getButton("icons/previous.png", "Go to previous track");
+        rewindButton = getButton("icons/rewind.png", "Skip backward");
+        playPauseToggleButton = getToggleButton("icons/play.png", "icons/pause.png", "Play/pause");
+        forwardButton = getButton("icons/forward.png", "Skip forward");
+        downButton = getButton("icons/down.png", "Go to next application");
+        volumeDownButton = getButton("icons/volumeDown.png", "Decrease volume");
+        muteToggleButton = getToggleButton("icons/mute.png", "icons/unmute.png", "Toggle Mute");
+        volumeUpButton = getButton("icons/volumeUp.png", "Increase volume");
+        repeatButton = getButton("icons/repeat.png", "Repeat");
+        shuffleButton = getButton("icons/shuffle.png", "Shuffle");
+    }
+
+    protected void layoutControls() {
+        setLayout(new BorderLayout());
+        layoutControlPanel();
+    }
+    
+    protected void layoutControlPanel() {
+        JPanel controlPanel = new JPanel();
+        controlPanel.setLayout(new BorderLayout());
+        
+        JPanel upperControlPanel = new JPanel();
+        controlPanel.add(upperControlPanel, BorderLayout.NORTH);
+        upperControlPanel.add(upButton);
+        upperControlPanel.add(previousButton);
+        upperControlPanel.add(rewindButton);
+        upperControlPanel.add(playPauseToggleButton);
+        upperControlPanel.add(forwardButton);
+        upperControlPanel.add(nextButton);
+        
+        JPanel lowerControlPanel = new JPanel();
+        controlPanel.add(lowerControlPanel, BorderLayout.SOUTH);
+        lowerControlPanel.add(downButton);
+        lowerControlPanel.add(repeatButton);
+        lowerControlPanel.add(volumeDownButton);
+        lowerControlPanel.add(muteToggleButton);
+        lowerControlPanel.add(volumeUpButton);
+        lowerControlPanel.add(shuffleButton);
+
+        add(controlPanel, BorderLayout.CENTER);
+    }
+
+    /* Listeners */
+    public void buttonPressed(HoldButton button) {
+        if (button.equals(previousButton)) {
+            panelDevice.buttonPressed(PanelButton.PREVIOUS);
+        } else if (button.equals(rewindButton)) {
+            panelDevice.buttonPressed(PanelButton.REWIND);
+        } else if (button.equals(playPauseToggleButton)) {
+            panelDevice.buttonPressed(PanelButton.PLAY);
+        } else if (button.equals(forwardButton)) {
+            panelDevice.buttonPressed(PanelButton.FORWARD);
+        } else if (button.equals(nextButton)) {
+            panelDevice.buttonPressed(PanelButton.NEXT);
+        } else if (button.equals(volumeDownButton)) {
+            panelDevice.buttonPressed(PanelButton.VOLUME_DOWN);
+        } else if (button.equals(muteToggleButton)) {
+            panelDevice.buttonPressed(PanelButton.MUTE);
+        } else if (button.equals(volumeUpButton)) {
+            panelDevice.buttonPressed(PanelButton.VOLUME_UP);
+        } else if (button.equals(repeatButton)) {
+            panelDevice.buttonPressed(PanelButton.REPEAT);
+        } else if (button.equals(shuffleButton)) {
+            panelDevice.buttonPressed(PanelButton.SHUFFLE);
+        } else if (button.equals(upButton)) {
+            panelDevice.buttonPressed(PanelButton.UP);
+        }  else if (button.equals(downButton)) {
+            panelDevice.buttonPressed(PanelButton.DOWN);
+        }
+    }
+
+    public void buttonReleased(HoldButton button) {
+        if (button.equals(previousButton)) {
+            panelDevice.buttonReleased(PanelButton.PREVIOUS);
+        } else if (button.equals(rewindButton)) {
+            panelDevice.buttonReleased(PanelButton.REWIND);
+        } else if (button.equals(playPauseToggleButton)) {
+            panelDevice.buttonReleased(PanelButton.PLAY);
+            playPauseToggleButton.toggle();
+        } else if (button.equals(forwardButton)) {
+            panelDevice.buttonReleased(PanelButton.FORWARD);
+        } else if (button.equals(nextButton)) {
+            panelDevice.buttonReleased(PanelButton.NEXT);
+        } else if (button.equals(volumeDownButton)) {
+            panelDevice.buttonReleased(PanelButton.VOLUME_DOWN);
+        } else if (button.equals(muteToggleButton)) {
+            panelDevice.buttonReleased(PanelButton.MUTE);
+            muteToggleButton.toggle();
+        } else if (button.equals(volumeUpButton)) {
+            panelDevice.buttonReleased(PanelButton.VOLUME_UP);
+        } else if (button.equals(repeatButton)) {
+            panelDevice.buttonReleased(PanelButton.REPEAT);
+        } else if (button.equals(shuffleButton)) {
+            panelDevice.buttonReleased(PanelButton.SHUFFLE);
+        } else if (button.equals(upButton)) {
+            panelDevice.buttonReleased(PanelButton.UP);
+        }  else if (button.equals(downButton)) {
+            panelDevice.buttonReleased(PanelButton.DOWN);
+        }
+    }
+
+    protected void processWindowEvent(WindowEvent event) {
+        if (event.getID() == WindowEvent.WINDOW_CLOSING) {
+            log.debug("Window closing");
+            panelDevice.stop();
+        }
+    }
+}

java/mimis/src/main/java/mimis/device/panel/PanelButton.java

@@ -0,0 +1,20 @@
+package mimis.device.panel;
+
+import mimis.input.Button;
+
+public enum PanelButton implements Button {
+    PREVIOUS,
+    REWIND,
+    STOP,
+    PAUSE,
+    PLAY,
+    FORWARD,
+    NEXT,
+    VOLUME_DOWN,
+    MUTE,
+    VOLUME_UP,
+    REPEAT,
+    SHUFFLE,
+    UP,
+    DOWN;
+}

java/mimis/src/main/java/mimis/device/panel/PanelDevice.java

@@ -0,0 +1,44 @@
+package mimis.device.panel;
+
+import mimis.device.Device;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.input.state.Press;
+import mimis.input.state.Release;
+import mimis.value.Action;
+import mimis.worker.Component;
+
+public class PanelDevice extends Component implements Device {
+    protected static final String TITLE = "Panel";
+    protected Panel panel;
+    protected PanelTaskMapCycle taskMapCycle;
+
+    public PanelDevice() {
+        super(TITLE);
+        taskMapCycle = new PanelTaskMapCycle();
+    }
+
+    protected void activate() throws ActivateException {
+        panel = new Panel(this);
+        parser(Action.ADD, taskMapCycle.player);
+        super.activate();
+    }
+
+    public boolean active() {
+        return active = panel != null;
+    }
+
+    protected void deactivate() throws DeactivateException {
+        super.deactivate();
+        panel.dispose();
+        panel = null;
+    }
+
+    public void buttonPressed(PanelButton panelButton) {
+        route(new Press(panelButton));
+    }
+
+    public void buttonReleased(PanelButton panelButton) {
+        route(new Release(panelButton));
+    }
+}

java/mimis/src/main/java/mimis/device/panel/PanelTaskMapCycle.java

@@ -0,0 +1,33 @@
+package mimis.device.panel;
+
+import mimis.input.Task;
+import mimis.input.state.Press;
+import mimis.state.TaskMap;
+import mimis.state.TaskMapCycle;
+import mimis.value.Action;
+import mimis.value.Target;
+
+public class PanelTaskMapCycle extends TaskMapCycle {
+    protected static final long serialVersionUID = 1L;
+
+    public TaskMap player;
+
+    public PanelTaskMapCycle() {
+        /* Player */
+        player = new TaskMap();
+        player.add(new Press(PanelButton.UP), new Task(Action.PREVIOUS, Target.MAIN));
+        player.add(new Press(PanelButton.PREVIOUS), new Task(Action.PREVIOUS, Target.CURRENT));
+        player.add(new Press(PanelButton.REWIND), new Task(Action.REWIND, Target.CURRENT));
+        player.add(new Press(PanelButton.STOP), new Task(Action.STOP, Target.CURRENT));
+        player.add(new Press(PanelButton.PAUSE), new Task(Action.PAUSE, Target.CURRENT));
+        player.add(new Press(PanelButton.PLAY), new Task(Action.PLAY, Target.CURRENT));
+        player.add(new Press(PanelButton.FORWARD), new Task(Action.FORWARD, Target.CURRENT));
+        player.add(new Press(PanelButton.DOWN), new Task(Action.NEXT, Target.MAIN));
+        player.add(new Press(PanelButton.NEXT), new Task(Action.NEXT, Target.CURRENT));
+        player.add(new Press(PanelButton.VOLUME_DOWN), new Task(Action.VOLUME_DOWN, Target.CURRENT));
+        player.add(new Press(PanelButton.MUTE), new Task(Action.MUTE, Target.CURRENT));
+        player.add(new Press(PanelButton.VOLUME_UP), new Task(Action.VOLUME_UP, Target.CURRENT));
+        player.add(new Press(PanelButton.REPEAT), new Task(Action.REPEAT, Target.CURRENT));
+        player.add(new Press(PanelButton.SHUFFLE), new Task(Action.SHUFFLE, Target.CURRENT));
+        add(player);
+    }

java/mimis/src/main/java/mimis/device/wiimote/WiimoteButton.java

@@ -0,0 +1,38 @@
+package mimis.device.wiimote;
+
+import mimis.exception.button.UnknownButtonException;
+import mimis.input.Button;
+
+public enum WiimoteButton implements Button {
+    TWO   (0x0001),
+    ONE   (0x0002),
+    B     (0x0004),
+    A     (0x0008),
+    MINUS (0x0010),
+    HOME  (0x0080),
+    LEFT  (0x0100),
+    RIGHT (0x0200),
+    DOWN  (0x0400),
+    UP    (0x0800),
+    PLUS  (0x1000),
+    ALL   (0x1F9F);
+
+    protected int code;
+
+    private WiimoteButton(int code) {
+        this.code = code;
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public static WiimoteButton create(int code) throws UnknownButtonException {
+        for (WiimoteButton button : WiimoteButton.values()) {
+            if (button.getCode() == code) {
+                return button;
+            }
+        }
+        throw new UnknownButtonException();
+    }
+}

java/mimis/src/main/java/mimis/device/wiimote/WiimoteDevice.java

@@ -0,0 +1,271 @@
+package mimis.device.wiimote;
+
+import java.io.IOException;
+
+import mimis.device.Device;
+import mimis.device.wiimote.gesture.GestureDevice;
+import mimis.device.wiimote.motion.MotionDevice;
+import mimis.exception.button.UnknownButtonException;
+import mimis.exception.device.DeviceNotFoundException;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.input.Button;
+import mimis.input.Feedback;
+import mimis.input.state.Press;
+import mimis.input.state.Release;
+import mimis.util.ArrayCycle;
+import mimis.value.Action;
+import mimis.value.Signal;
+import mimis.worker.Component;
+import mimis.worker.Worker;
+
+import org.wiigee.event.GestureEvent;
+import org.wiigee.event.GestureListener;
+import org.wiigee.util.Log;
+
+import wiiusej.Wiimote;
+import wiiusej.wiiusejevents.physicalevents.IREvent;
+import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
+import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
+
+public class WiimoteDevice extends Component implements Device, GestureListener {
+    protected static final String TITLE = "Wiimote";
+    protected static final int RUMBLE = 50;
+    protected static final int CONNECTED_TIMEOUT = 500;
+    protected static final int LED_TIMEOUT = 1000;
+    protected static final int LED_SLEEP = 50;
+
+    protected static WiimoteService wiimoteService;
+    protected WiimoteTaskMapCycle taskMapCycle;
+    protected Wiimote wiimote;
+    protected boolean connected;
+    protected GestureDevice gestureDevice;
+    protected MotionDevice motionDevice;
+    protected int gestureId;
+    protected LedWorker ledWorker;
+    protected boolean disconnect;
+
+    static {
+        WiimoteDevice.wiimoteService = new WiimoteService();
+        Log.setLevel(Log.DEBUG);
+    }
+
+    public WiimoteDevice() {
+        super(TITLE);
+        taskMapCycle = new WiimoteTaskMapCycle();
+        gestureDevice = new GestureDevice();
+        gestureDevice.add(this);
+        motionDevice = new MotionDevice(this);
+        gestureId = 0;
+        ledWorker = new LedWorker();
+    }
+
+    /* Worker */
+    protected void activate() throws ActivateException {
+    	if (wiimote == null) {
+            motionDevice.setRouter(router);
+            motionDevice.start();
+            parser(Action.ADD, taskMapCycle.player);
+        }
+        try {
+            connect();
+        } catch (DeviceNotFoundException e) {
+            log.warn(e);
+        }
+        super.activate();
+    }
+
+    public synchronized boolean active() {
+        if (wiimote != null) {
+            connected = false;
+            wiimote.getStatus();
+            try {
+                wait(CONNECTED_TIMEOUT);
+            } catch (InterruptedException e) {
+                log.error(e);
+            }
+            if (!connected) {
+                try {
+                    connect();
+                } catch (DeviceNotFoundException e) {
+                    disconnect = true;
+                    stop();
+                }
+            }
+        }
+        return active;
+    }
+
+    protected void deactivate() throws DeactivateException {
+        super.deactivate();
+        ledWorker.stop();
+        motionDevice.stop();
+        if (disconnect && wiimote != null) {
+            wiimote.disconnect();
+            disconnect = false;
+        }
+    }
+
+    public void exit() {
+        super.exit();
+        ledWorker.exit();
+        if (wiimote != null) {
+            wiimote.disconnect();
+            wiimote = null;
+        }
+        wiimoteService.exit();
+        motionDevice.exit();
+    }
+
+    /* Events */
+    public void begin(Action action) {
+        switch (action) {
+            case SHIFT:
+                log.debug("Shift");
+                parser(Action.RESET, taskMapCycle.player);
+                parser(Action.ADD, taskMapCycle.mimis);
+                parser(Action.ADD, taskMapCycle.like);
+                break;
+            case UNSHIFT:
+                log.debug("Unshift");
+                parser(Action.RESET, taskMapCycle.mimis);
+                parser(Action.RESET, taskMapCycle.like);
+                parser(Action.ADD, taskMapCycle.player);
+                break;
+            case RECOGNIZE:
+                log.debug("Gesture recognize press");
+                gestureDevice.recognize(Signal.BEGIN);
+                break;
+            case TRAIN:
+                log.debug("Gesture train press");
+                gestureDevice.train(Signal.BEGIN);
+                break;
+            case CLOSE:
+                log.debug("Gesture close press");
+                gestureDevice.close(Signal.BEGIN);
+                break;
+            case SAVE:
+                log.debug("Gesture save");
+                gestureDevice.close(Signal.END);
+                gestureDevice.saveGesture(gestureId, "tmp/gesture #" + gestureId);
+                ++gestureId;
+                break;
+            case LOAD:
+                log.debug("Gesture load");
+                for (int i = 0; i < gestureId; ++i) {
+                    gestureDevice.loadGesture("tmp/gesture #" + gestureId);
+                }
+                break;
+        }
+    }
+
+    public void end(Action action) {
+        switch (action) {
+            case RECOGNIZE:
+                log.debug("Gesture recognize release");
+                gestureDevice.recognize(Signal.END);
+                break;
+            case TRAIN:
+                log.debug("Gesture train release");
+                gestureDevice.train(Signal.END);
+                break;
+            case CLOSE:
+                log.debug("Gesture close release");
+                gestureDevice.close(Signal.END);
+                break;
+        }
+    }
+
+    public void feedback(Feedback feedback) {
+        if (wiimote != null && active()) {
+            log.debug("Wiimote rumble feedback");
+            wiimote.rumble(RUMBLE);
+        }
+    }
+
+    /* Connectivity */
+    public synchronized void connect() throws DeviceNotFoundException {
+        wiimote = wiimoteService.getDevice(this);
+        //wiimote.activateContinuous();
+        //wiimote.activateMotionSensing();
+        ledWorker.start();
+    }
+
+    /* Listeners */
+    public void onButtonsEvent(WiimoteButtonsEvent event) {
+    	if (!active) {
+    		return;
+    	}
+        int pressed = event.getButtonsJustPressed() - event.getButtonsHeld();
+        int released = event.getButtonsJustReleased();
+        try {
+            if (pressed != 0 && released == 0) {
+                Button button = WiimoteButton.create(pressed);
+                log.trace("Press: " + button);
+                route(new Press(button));
+            } else if (pressed == 0 && released != 0) {
+                Button button = WiimoteButton.create(released);
+                log.trace("Release: " + button);
+                route(new Release(button));
+            }
+        } catch (UnknownButtonException e) {}
+    }
+
+    public void onMotionSensingEvent(MotionSensingEvent event) {
+    	if (!active) {
+    		return;
+    	}
+        gestureDevice.add(event.getGforce());
+        motionDevice.add(event);
+    }
+
+    public void onIrEvent(IREvent event) {
+        
+    }
+
+    public void gestureReceived(GestureEvent event) {
+        log.debug(event.isValid());
+        if (event.isValid()) {
+            System.out.printf("id #%d, prob %.0f%%, valid %b\n", event.getId(), 100 * event.getProbability(), event.isValid());
+        }
+    }
+
+    class LedWorker extends Worker {
+        protected ArrayCycle<Integer> ledCycle;
+
+        public LedWorker() {
+            ledCycle = new ArrayCycle<Integer>();
+            ledCycle.add(1);
+            ledCycle.add(3);
+            ledCycle.add(6);
+            ledCycle.add(12);
+            ledCycle.add(8);
+            ledCycle.add(12);
+            ledCycle.add(6);
+            ledCycle.add(3);
+            ledCycle.add(1);
+        }
+
+        public void activate() throws ActivateException {
+            sleep(LED_TIMEOUT);
+            super.activate();
+        }
+        
+        public void deactivate() throws DeactivateException {
+            super.deactivate();
+            setLeds(1);
+        }
+
+        protected void work() {
+            setLeds(ledCycle.next());
+            sleep(LED_SLEEP);
+        }
+
+        protected void setLeds(int leds) {
+            if (wiimote != null) {
+                wiimote.setLeds((leds & 1) > 0, (leds & 2) > 0, (leds & 4) > 0, (leds & 8) > 0);
+                sleep((leds == 8 ? 2 : 1) * LED_SLEEP);
+            }
+        }
+    }
+}

java/mimis/src/main/java/mimis/device/wiimote/WiimoteDiscovery.java

@@ -0,0 +1,80 @@
+package mimis.device.wiimote;
+
+import java.io.IOException;
+import java.util.Scanner;
+
+import mimis.exception.device.DeviceNotFoundException;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.worker.Worker;
+
+public class WiimoteDiscovery extends Worker {
+    protected static final String WIISCAN = "wiiscan";
+    protected static final int TIMEOUT = 1000;
+    protected WiimoteDevice wiimoteDevice;
+    protected Process process;
+    protected boolean disconnect;
+
+    public WiimoteDiscovery(WiimoteDevice wiimoteDevice) {
+        this.wiimoteDevice = wiimoteDevice;
+    }
+
+    protected boolean connect() {
+        log.debug("Connect");
+        return execute("-c nintendo"); // Nintendo RVL-CNT-01 RVL-WBC-01
+    }
+
+    protected boolean disconnect() {
+        log.debug("Disconnect");
+        return execute("-d nintendo");
+    }
+
+    public boolean execute(String parameters) {
+        String command = WIISCAN + " -l wiiuse " + parameters;
+        try {
+            process = Runtime.getRuntime().exec(command);
+            Scanner scanner = new Scanner(process.getInputStream());
+            while (scanner.hasNext()) {
+                String line = scanner.nextLine();
+                if (line.contains("error: BluetoothSetServiceState()")) {
+                    disconnect = true;
+                    return false;
+                } else if (line.contains("[OK]")) {
+                    return true;
+                }
+            }
+        } catch (IOException e) {
+            log.error(e);
+        } finally {
+            process = null;
+        }
+        return false;
+    }
+
+    public void activate() throws ActivateException {
+        super.activate();
+    }
+
+    public void deactivate() throws DeactivateException {
+        super.deactivate();
+        if (process != null) {
+            process.destroy();
+        }
+    }
+
+    protected void work() {
+        if (disconnect) {
+            disconnect();
+            disconnect = false;
+        }
+        if (connect()) {
+            log.debug("Connected");
+            try {
+                sleep(TIMEOUT);
+                wiimoteDevice.connect();
+            } catch (DeviceNotFoundException e) {
+                disconnect = true;
+            }
+        }
+    }
+}

java/mimis/src/main/java/mimis/device/wiimote/WiimoteService.java

@@ -0,0 +1,122 @@
+package mimis.device.wiimote;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import mimis.exception.device.DeviceNotFoundException;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import wiiusej.WiiUseApiManager;
+import wiiusej.Wiimote;
+import wiiusej.wiiusejevents.GenericEvent;
+import wiiusej.wiiusejevents.physicalevents.ExpansionEvent;
+import wiiusej.wiiusejevents.physicalevents.IREvent;
+import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
+import wiiusej.wiiusejevents.physicalevents.WiimoteButtonsEvent;
+import wiiusej.wiiusejevents.utils.WiimoteListener;
+import wiiusej.wiiusejevents.wiiuseapievents.BalanceBoardInsertedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.BalanceBoardRemovedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerInsertedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.ClassicControllerRemovedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.DisconnectionEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroInsertedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.GuitarHeroRemovedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.NunchukInsertedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.NunchukRemovedEvent;
+import wiiusej.wiiusejevents.wiiuseapievents.StatusEvent;
+
+public class WiimoteService extends WiiUseApiManager implements WiimoteListener {
+    protected Log log = LogFactory.getLog(getClass());
+    
+    /*public static void main(String[] args) {
+        Log log = LogFactory.getLog(WiimoteService.class);
+        for (Wiimote wm : WiiUseApiManager.getWiimotes(1, false)) {
+            log.debug(wm);
+        }
+    }*/
+
+    protected final boolean RUMBLE = false;
+
+    protected ArrayList<Integer> wiimoteList;
+    protected Wiimote[] wiimoteArray;
+    protected HashMap<Integer, WiimoteDevice> wiimoteDeviceMap;
+
+    public WiimoteService() {
+       wiimoteList = new ArrayList<Integer>();
+       wiimoteArray = new Wiimote[0];
+       wiimoteDeviceMap = new HashMap<Integer, WiimoteDevice>();
+    }
+
+    public void exit() {
+        if (wiimoteArray != null) {
+            for (Wiimote wiimote : wiimoteArray) {
+                wiimote.disconnect();
+            }
+        }
+        definitiveShutdown();
+    }
+
+    public Wiimote getDevice(WiimoteDevice wiimoteDevice) throws DeviceNotFoundException {
+        Wiimote[] wiimoteArray = getWiimotes(1, RUMBLE);
+        for (Wiimote wiimote : wiimoteArray) {
+            int id = wiimote.getId();
+            if (!wiimoteList.contains(id)) {
+                wiimote.addWiiMoteEventListeners(this);
+                wiimoteList.add(id);
+                wiimoteDeviceMap.put(id, wiimoteDevice);
+            }
+            return wiimote;
+        }
+        throw new DeviceNotFoundException();
+    }
+
+    public Wiimote getWiimote(GenericEvent event) {
+        return wiimoteArray[event.getWiimoteId() - 1];
+    }
+
+    public WiimoteDevice getWiimoteDevice(GenericEvent event){
+        return wiimoteDeviceMap.get(event.getWiimoteId());
+    }
+
+    public void onButtonsEvent(WiimoteButtonsEvent event) {
+    	getWiimoteDevice(event).onButtonsEvent(event);
+    }
+
+    public void onMotionSensingEvent(MotionSensingEvent event) {
+
+        getWiimoteDevice(event).onMotionSensingEvent(event);
+    }
+
+    public void onStatusEvent(StatusEvent event) {
+        if (event.isConnected()) {
+            WiimoteDevice wiimoteDevice = getWiimoteDevice(event);            
+            wiimoteDevice.connected = true;
+            synchronized (wiimoteDevice) {
+                wiimoteDevice.notifyAll();
+            }
+        }
+    }
+
+    public void onIrEvent(IREvent event) {
+        getWiimoteDevice(event).onIrEvent(event);
+    }
+
+    public void onExpansionEvent(ExpansionEvent event) {}
+    public void onDisconnectionEvent(DisconnectionEvent event) {}
+    public void onNunchukInsertedEvent(NunchukInsertedEvent event) {}
+    public void onNunchukRemovedEvent(NunchukRemovedEvent event) {}
+    public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent event) {}
+    public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent event) {}
+    public void onClassicControllerInsertedEvent(ClassicControllerInsertedEvent event) {}
+    public void onClassicControllerRemovedEvent(ClassicControllerRemovedEvent event) {}
+
+    public void onBalanceBoardInsertedEvent(BalanceBoardInsertedEvent e) {
+        log.debug(e);        
+    }
+
+    public void onBalanceBoardRemovedEvent(BalanceBoardRemovedEvent e) {
+        
+    }
+}

java/mimis/src/main/java/mimis/device/wiimote/WiimoteTaskMapCycle.java

@@ -0,0 +1,50 @@
+package mimis.device.wiimote;
+
+import mimis.input.Task;
+import mimis.input.state.Release;
+import mimis.state.TaskMap;
+import mimis.state.TaskMapCycle;
+import mimis.value.Action;
+import mimis.value.Target;
+
+public class WiimoteTaskMapCycle extends TaskMapCycle {
+    protected static final long serialVersionUID = 1L;
+
+    public TaskMap mimis, player, gesture, like;
+
+    public WiimoteTaskMapCycle() {
+        /* Mimis */
+        mimis = new TaskMap();
+        mimis.add(WiimoteButton.HOME, new Task(Action.NEXT, Target.MAIN));
+        mimis.add(new Release(WiimoteButton.B), new Task(Action.UNSHIFT, Target.SELF));
+
+        /* Gesture */
+        gesture = new TaskMap();
+        gesture.add(WiimoteButton.A, new Task(Action.TRAIN, Target.SELF));
+        gesture.add(WiimoteButton.B, new Task(Action.SAVE, Target.SELF));
+        gesture.add(WiimoteButton.DOWN, new Task(Action.LOAD, Target.SELF));
+        gesture.add(WiimoteButton.HOME, new Task(Action.RECOGNIZE, Target.SELF));
+        add(gesture);
+
+        /* Player */
+        player = new TaskMap();
+        player.add(WiimoteButton.A, new Task(Action.PLAY, Target.CURRENT));
+        player.add(WiimoteButton.B, new Task(Action.SHIFT, Target.SELF));
+        player.add(WiimoteButton.HOME, new Task(Action.MUTE, Target.CURRENT));
+        player.add(WiimoteButton.ONE, new Task(Action.SHUFFLE, Target.CURRENT));
+        player.add(WiimoteButton.TWO, new Task(Action.REPEAT, Target.CURRENT));
+        player.add(WiimoteButton.UP, new Task(Action.NEXT, Target.CURRENT));
+        player.add(WiimoteButton.DOWN, new Task(Action.PREVIOUS, Target.CURRENT));    
+        player.add(WiimoteButton.RIGHT, new Task(Action.FORWARD, Target.CURRENT));
+        player.add(WiimoteButton.LEFT, new Task(Action.REWIND, Target.CURRENT));
+        player.add(WiimoteButton.MINUS, new Task(Action.VOLUME_DOWN, Target.CURRENT));
+        player.add(WiimoteButton.PLUS, new Task(Action.VOLUME_UP, Target.CURRENT));
+        add(player);
+
+        /* Like */
+        like = new TaskMap();
+        like.add(WiimoteButton.PLUS, new Task(Action.LIKE, Target.CURRENT));
+        like.add(WiimoteButton.MINUS, new Task(Action.DISLIKE, Target.CURRENT));
+        add(like);
+    }
+}

java/mimis/src/main/java/mimis/device/wiimote/gesture/GestureDevice.java

@@ -0,0 +1,112 @@
+package mimis.device.wiimote.gesture;
+
+import mimis.value.Signal;
+
+import org.wiigee.device.Device;
+import org.wiigee.event.AccelerationEvent;
+import org.wiigee.event.AccelerationListener;
+import org.wiigee.event.ButtonListener;
+import org.wiigee.event.ButtonPressedEvent;
+import org.wiigee.event.ButtonReleasedEvent;
+import org.wiigee.event.GestureListener;
+import org.wiigee.event.MotionStartEvent;
+import org.wiigee.event.MotionStopEvent;
+
+import wiiusej.values.GForce;
+
+public class GestureDevice extends Device implements AccelerationListener {
+    public static final boolean AUTOFILTERING = true;
+    public static final boolean AUTOMOTION = false;
+
+    public GestureDevice() {
+        this(AUTOFILTERING, AUTOMOTION);
+    }
+
+    public GestureDevice(boolean autofiltering, boolean automotion) {
+        super(autofiltering);
+        if (automotion) {
+            addAccelerationListener(this);
+        }
+        this.setRecognitionButton(ButtonPressedEvent.BUTTON_A);
+        this.setTrainButton(ButtonPressedEvent.BUTTON_B);
+        this.setCloseGestureButton(ButtonPressedEvent.BUTTON_HOME);
+    }
+
+    public void add(GestureListener gestureListener) {
+        addGestureListener(gestureListener);
+    }
+
+    public void add(GForce gforce) {
+        add(new double[] {
+            gforce.getX(),
+            gforce.getY(),
+            gforce.getY()});        
+    }
+
+    public void add(double[] vector) {
+        //System.out.printf("%f %f %f\n", vector[0], vector[1], vector[2]);
+        fireAccelerationEvent(vector);
+    }
+
+    public void recognize(Signal signal) { 
+        switch (signal) {
+            case BEGIN:
+                fireButtonPressedEvent(ButtonPressedEvent.BUTTON_A);
+                break;
+            case END:
+                fireButtonReleasedEvent(ButtonPressedEvent.BUTTON_A);
+                break;
+        }
+    }
+
+    public void train(Signal signal) {
+        switch (signal) {
+            case BEGIN:
+                fireButtonPressedEvent(ButtonPressedEvent.BUTTON_B);
+                break;
+            case END:
+                fireButtonReleasedEvent(ButtonPressedEvent.BUTTON_B);
+                break;
+        }
+    }
+
+    public void close(Signal signal) {
+        switch (signal) {
+            case BEGIN:
+                fireButtonPressedEvent(ButtonPressedEvent.BUTTON_HOME);
+                break;
+            case END:
+                fireButtonReleasedEvent(ButtonPressedEvent.BUTTON_HOME);
+                break;
+        }
+    }
+
+    public void fireButtonPressedEvent(int button) {
+        ButtonPressedEvent buttonPressedEvent = new ButtonPressedEvent(this, button);
+        for (ButtonListener buttonListener : buttonlistener) {
+            buttonListener.buttonPressReceived(buttonPressedEvent);
+        }
+        if (buttonPressedEvent.isRecognitionInitEvent() || buttonPressedEvent.isTrainInitEvent()) {
+            resetAccelerationFilters();
+        }
+    }
+
+    public void fireButtonReleasedEvent(int button) {
+        ButtonReleasedEvent buttonReleasedEvent = new ButtonReleasedEvent(this, button); 
+        for (ButtonListener buttonListener : buttonlistener) {
+            buttonListener.buttonReleaseReceived(buttonReleasedEvent);
+        }
+    }
+
+    public void accelerationReceived(AccelerationEvent event) {}
+
+    public void motionStartReceived(MotionStartEvent event) {
+        System.out.println("Motion start !" + System.currentTimeMillis());
+        recognize(Signal.BEGIN);
+    }
+
+    public void motionStopReceived(MotionStopEvent event) {
+        System.out.println("Motion stop! " +  + System.currentTimeMillis());
+        recognize(Signal.END);
+    }
+}

java/mimis/src/main/java/mimis/device/wiimote/motion/MotionData.java

@@ -0,0 +1,29 @@
+package mimis.device.wiimote.motion;
+
+import java.io.Serializable;
+
+import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
+
+public class MotionData implements Serializable {
+    protected static final long serialVersionUID = 1L;
+
+    protected int time;
+    protected MotionSensingEvent event;
+
+    public MotionData(long time, MotionSensingEvent event) {
+        this((int) time, event);
+    }
+
+    public MotionData(int time, MotionSensingEvent event) {
+        this.time = time;
+        this.event = event;
+    }
+
+    public int getTime() {
+        return time;
+    }
+
+    public MotionSensingEvent getEvent() {
+        return event;
+    }
+}

java/mimis/src/main/java/mimis/device/wiimote/motion/MotionDevice.java

@@ -0,0 +1,190 @@
+package mimis.device.wiimote.motion;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.ArrayList;
+
+import mimis.device.lirc.LircButton;
+import mimis.device.lirc.remote.PhiliphsRCLE011Button;
+import mimis.device.wiimote.WiimoteDevice;
+import mimis.exception.worker.ActivateException;
+import mimis.exception.worker.DeactivateException;
+import mimis.input.Button;
+import mimis.input.button.ColorButton;
+import mimis.input.button.NumberButton;
+import mimis.input.state.State;
+import mimis.value.Action;
+import mimis.worker.Component;
+import mimis.worker.Worker;
+import wiiusej.wiiusejevents.physicalevents.MotionSensingEvent;
+
+public class MotionDevice extends Component {
+    protected WiimoteDevice wiimoteDevice;
+    protected int id;
+    protected long start;
+    protected boolean replay;
+    protected Action action;
+
+    public ReplayWorker replayWorker;
+    public ArrayList<MotionData> motionList;
+
+    public MotionDevice(WiimoteDevice wiimoteDevice) {
+        this.wiimoteDevice = wiimoteDevice;
+        id = 0;
+        start = -1;
+        replay = false;
+        action = Action.TRAIN;
+        replayWorker = new ReplayWorker();
+        motionList = new ArrayList<MotionData>();
+    }
+
+    public void activate() throws ActivateException {
+        super.activate();
+        listen(State.class);
+    }
+
+    public void deactivate() throws DeactivateException {
+        replayWorker.stop();
+        super.deactivate();
+    }
+
+    public void exit() {
+        super.exit();
+        replayWorker.exit();
+    }
+
+    public void release(Button button) {
+        if (button instanceof LircButton) {
+            PhiliphsRCLE011Button lircButton = (PhiliphsRCLE011Button) button;
+            log.debug(lircButton);
+            switch (lircButton) {
+                case CLOCK:
+                    action = Action.TRAIN;
+                    break;
+                case OUT:
+                    action = Action.RECOGNIZE;
+                    break;
+                case MUTE:
+                    wiimoteDevice.begin(Action.CLOSE);
+                    break;
+                case SCREEN_UP:
+                    wiimoteDevice.begin(Action.SAVE);
+                    break;
+                case SCREEN_DOWN:
+                    wiimoteDevice.begin(Action.LOAD);
+                    break;
+            }
+        } else if (button instanceof NumberButton) {
+            NumberButton numberButton = (NumberButton) button;
+            id = numberButton.ordinal();
+            if (replay == false) {
+                release(ColorButton.YELLOW);
+            } else {
+                log.debug("Set file to #" + id);
+            }
+        } else if (button instanceof ColorButton) {
+            ColorButton colorButton = (ColorButton) button;
+            log.debug(colorButton.name());
+            synchronized (motionList) {
+                switch (colorButton) {
+                    case GREEN:
+                        log.debug("Start capturing motion");
+                        motionList.clear();
+                        start = System.currentTimeMillis();
+                        break;
+                    case RED:
+                        if (replayWorker.active()) {
+                            log.debug("Stop replaying motion");
+                            replayWorker.stop();
+                        } else {
+                            log.debug("Writing motion to file #" + id);
+                            try {                            
+                                FileOutputStream fileOutputStream = new FileOutputStream(String.format("tmp/motion #%d.bin", id));
+                                ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
+                                objectOutputStream.writeObject(motionList.size());
+                                for (MotionData motionData : motionList) {
+                                    objectOutputStream.writeObject(motionData);
+                                }
+                                objectOutputStream.close();
+                            } catch (IOException e) {
+                                log.error(e);
+                            }
+                            motionList.clear();
+                            start = -1;
+                        }
+                        break;
+                    case YELLOW:
+                        log.debug("Replaying motion from file #" + id);
+                        replay = true;
+                        replayWorker.start();
+                        break;
+                }
+            }
+        }
+    }
+
+    public void add(MotionSensingEvent event) {
+        if (start > 0) {
+            synchronized (motionList) {
+                motionList.add(new MotionData(System.currentTimeMillis() - start, event));
+            }
+        }
+    }
+
+    class ReplayWorker extends Worker {
+        protected ObjectInputStream objectInputStream;
+        protected int count, i, time;
+
+        protected void activate() throws ActivateException {
+            try {
+                FileInputStream fileInputStream = new FileInputStream(String.format("tmp/motion #%d.bin", id));
+                objectInputStream = new ObjectInputStream(fileInputStream);
+                count = (Integer) objectInputStream.readObject();
+                i = time = 0;
+                wiimoteDevice.begin(action);
+                super.activate();
+                return;
+            } catch (FileNotFoundException e) {
+                log.error(e);
+            } catch (IOException e) {
+                log.error(e);
+            } catch (ClassNotFoundException e) {
+                log.error(e);
+            }
+        }
+
+        protected void deactivate() throws DeactivateException {
+            log.debug(String.format("Replay stopped (%d ms)", time));
+            wiimoteDevice.end(action);
+            replay = false;
+            try {
+                objectInputStream.close();
+            } catch (IOException e) {
+                log.debug(e);
+            }
+            super.deactivate();
+        }
+        protected void work() {
+            if (i++ < count) {                
+                try {
+                    Object object = objectInputStream.readObject();
+                    MotionData motionData = (MotionData) object;
+                    wiimoteDevice.onMotionSensingEvent(motionData.getEvent());
+                    sleep(motionData.getTime() - time);
+                    time = motionData.getTime();                    
+                    return;
+                } catch (IOException e) {
+                    log.error(e);
+                } catch (ClassNotFoundException e) {
+                    log.error(e);
+                }
+            }
+            stop();
+        }        
+    }
+
+}

java/mimis/src/main/java/mimis/exception/ApplicationException.java

@@ -0,0 +1,5 @@
+package mimis.exception;
+
+public class ApplicationException extends HandlerException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/ButtonException.java

@@ -0,0 +1,5 @@
+package mimis.exception;
+
+public class ButtonException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/DeviceException.java

@@ -0,0 +1,5 @@
+package mimis.exception;
+
+public class DeviceException extends HandlerException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/EventException.java

@@ -0,0 +1,5 @@
+package mimis.exception;
+
+public class EventException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/ExitException.java

@@ -0,0 +1,5 @@
+package mimis.exception;
+
+public class ExitException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/HandlerException.java

@@ -0,0 +1,5 @@
+package mimis.exception;
+
+public class HandlerException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/InitialiseException.java

@@ -0,0 +1,5 @@
+package mimis.exception;
+
+public class InitialiseException extends HandlerException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/MacroException.java

@@ -0,0 +1,9 @@
+package mimis.exception;
+
+public class MacroException extends Exception {
+    protected static final long serialVersionUID = 1L;
+
+    public MacroException(String message) {
+        super(message);
+    }
+}

java/mimis/src/main/java/mimis/exception/TaskException.java

@@ -0,0 +1,5 @@
+package mimis.exception;
+
+public class TaskException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/WorkerException.java

@@ -0,0 +1,5 @@
+package mimis.exception;
+
+public class WorkerException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/application/ApplicationExitException.java

@@ -0,0 +1,7 @@
+package mimis.exception.application;
+
+import mimis.exception.ApplicationException;
+
+public class ApplicationExitException extends ApplicationException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/application/ApplicationInitialiseException.java

@@ -0,0 +1,7 @@
+package mimis.exception.application;
+
+import mimis.exception.InitialiseException;
+
+public class ApplicationInitialiseException extends InitialiseException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/application/windows/WindowsApplicationException.java

@@ -0,0 +1,7 @@
+package mimis.exception.application.windows;
+
+import mimis.exception.ApplicationException;
+
+public class WindowsApplicationException extends ApplicationException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/button/UnknownButtonException.java

@@ -0,0 +1,7 @@
+package mimis.exception.button;
+
+import mimis.exception.ButtonException;
+
+public class UnknownButtonException extends ButtonException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/button/UnknownDirectionException.java

@@ -0,0 +1,7 @@
+package mimis.exception.button;
+
+import mimis.exception.ButtonException;
+
+public class UnknownDirectionException extends ButtonException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/device/DeviceExitException.java

@@ -0,0 +1,7 @@
+package mimis.exception.device;
+
+import mimis.exception.DeviceException;
+
+public class DeviceExitException extends DeviceException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/device/DeviceInitialiseException.java

@@ -0,0 +1,7 @@
+package mimis.exception.device;
+
+import mimis.exception.InitialiseException;
+
+public class DeviceInitialiseException extends InitialiseException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/device/DeviceNotFoundException.java

@@ -0,0 +1,5 @@
+package mimis.exception.device;
+
+public class DeviceNotFoundException extends DeviceInitialiseException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/device/JavaInputDeviceException.java

@@ -0,0 +1,7 @@
+package mimis.exception.device;
+
+import mimis.exception.DeviceException;
+
+public class JavaInputDeviceException extends DeviceException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/device/javainput/JavaInputDeviceSpecificException.java

@@ -0,0 +1,7 @@
+package mimis.exception.device.javainput;
+
+import mimis.exception.DeviceException;
+
+public class JavaInputDeviceSpecificException extends DeviceException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/event/SpreaderException.java

@@ -0,0 +1,7 @@
+package mimis.exception.event;
+
+import mimis.exception.EventException;
+
+public class SpreaderException extends EventException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/event/router/GlobalRouterException.java

@@ -0,0 +1,7 @@
+package mimis.exception.event.router;
+
+import mimis.exception.event.SpreaderException;
+
+public class GlobalRouterException extends SpreaderException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/macro/StateOrderException.java

@@ -0,0 +1,11 @@
+package mimis.exception.macro;
+
+import mimis.exception.MacroException;
+
+public class StateOrderException extends MacroException {
+    protected static final long serialVersionUID = 1L;
+
+    public StateOrderException(String message) {
+        super(message);
+    }
+}

java/mimis/src/main/java/mimis/exception/task/ActionException.java

@@ -0,0 +1,7 @@
+package mimis.exception.task;
+
+import mimis.exception.TaskException;
+
+public class ActionException extends TaskException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/task/TaskNotSupportedException.java

@@ -0,0 +1,5 @@
+package mimis.exception.task;
+
+public class TaskNotSupportedException extends Exception {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/task/action/ActionDeserializeException.java

@@ -0,0 +1,7 @@
+package mimis.exception.task.action;
+
+import mimis.exception.task.ActionException;
+
+public class ActionDeserializeException extends ActionException {
+    protected static final long serialVersionUID = 1L;
+}

java/mimis/src/main/java/mimis/exception/util/SendCommandException.java

@@ -0,0 +1,7 @@
+package mimis.exception.util;
+
+import mimis.exception.application.windows.WindowsApplicationException;
+
+public class SendCommandException extends WindowsApplicationException {
+    protected static final long serialVersionUID = 1L;
+}