Structuur consequenter gemaakt met initialise en exit methoden. De start methode wordt gereserveerd voor wanneer er een Thread moet worden gestart. Exceptions georganiseerd, hierbij opletten op het doorgeven van exceptions vanuit Threads! Poging tot het dynamisch toevoegen van devices is niet helemaal gelukt.

java/src/pm/Application.java

@@ -1,7 +1,22 @@
 package pm;
 
+import pm.exception.application.ApplicationExitException;
+import pm.exception.application.ApplicationInitialiseException;
 import pm.listener.ActionListener;
 
 public abstract class Application extends ActionListener {  
-    public void exit() {}
+    public void run() {
+        try {
+            initialise();
+            super.run();
+        } catch (ApplicationInitialiseException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void initialise() throws ApplicationInitialiseException {}
+
+    public void exit() throws ApplicationExitException {
+        stop();
+    }
 }

java/src/pm/Main.java

@@ -1,57 +1,67 @@
 package pm;
 
 import java.util.ArrayList;
-import pm.application.example.ExampleApplication;
+
+import pm.application.Winamp.WinampApplication;
 import pm.application.iTunes.iTunesApplication;
 import pm.device.Device;
 import pm.device.javainput.rumblepad.RumblepadDevice;
+import pm.device.jintellitype.JIntellitypeDevice;
 import pm.exception.action.TargetNotSetException;
+import pm.exception.application.ApplicationExitException;
+import pm.exception.device.DeviceExitException;
+import pm.exception.device.DeviceInitialiseException;
 import pm.listener.ActionListener;
 import pm.listener.ActionProvider;
 import pm.util.ArrayCycle;
 
 public class Main extends ActionListener {
-    ArrayCycle<Application> applicationCycle;
+    //protected String[] deviceClassArray;
-    ArrayList<Device> deviceList;
+    protected ArrayCycle<Application> applicationCycle;
-
+    protected ArrayList<Device> deviceList;
-    boolean run;
 
     public Main() {
         super();
+        /*deviceClassArray = new String[] {
+            "pm.device.jintellitype.JIntellitypeDevice",
+            "pm.device.javainput.rumblepad.RumblepadDevice",
+            "pm.device.javainput.extreme3d.Extreme3DDevice",
+            "pm.device.wiimote.WiimoteDevice"};*/
         applicationCycle = new ArrayCycle<Application>();
         deviceList = new ArrayList<Device>();
         ActionProvider.initialise(actionQueue);
     }
 
-    public void start() throws Exception {
+    public void initialise() throws DeviceInitialiseException {
-        //add(new ExampleDevice());
+        add(new JIntellitypeDevice());
         add(new RumblepadDevice());
-        //add(new Extreme3DDevice());
-        //add(new JIntellitypeDevice());
-        //add(new WiimoteDevice());
         for (Device device : deviceList) {
-            device.start();
+            device.initialise();
         }
-
+        //add(new ExampleApplication());
-        add(new ExampleApplication());
+        add(new WinampApplication());
         add(new iTunesApplication());
-        //add(new WinampApplication());
+        
-        applicationCycle.next();
+        //applicationCycle.next();
         for (Application application : applicationCycle) {
             application.start();
         }
-        run();
     }
 
     public void exit() {
-        run = false;
+        try {
+            System.out.println("Exit devices...");
             for (Device device : deviceList) {
                 device.exit();    
             }
+            System.out.println("Exit applications...");
             for (Application application : applicationCycle) {
                 application.exit();
             }
-        System.out.println("Main exit...");
+        } catch (DeviceExitException e) {
+        } catch (ApplicationExitException e) {}
+        System.out.println("Exit main...");
+        stop();
     }
 
     protected void action(Action action) {
@@ -76,6 +86,27 @@ public class Main extends ActionListener {
         } catch (TargetNotSetException e) {}
     }
 
+    /*protected void addDevices() throws DeviceInitialiseException {
+        for (String deviceClass : deviceClassArray) {
+            try {
+                Object object = Class.forName(deviceClass).getConstructor((Class[]) null).newInstance();
+                if (object instanceof Application) {
+                    Device device = (Device) object;
+                    add(device);
+                    try {
+                        device.initialise();
+                    } catch (DeviceNotFoundException e) {}
+                }
+            } catch (IllegalArgumentException e) {
+            } catch (SecurityException e) {
+            } catch (InstantiationException e) {
+            } catch (IllegalAccessException e) {
+            } catch (InvocationTargetException e) {
+            } catch (NoSuchMethodException e) {
+            } catch (ClassNotFoundException e) {}
+        }
+    }*/
+
     /* Add / remove methods */
     protected void add(Application application) {
         applicationCycle.add(application);
@@ -95,7 +126,9 @@ public class Main extends ActionListener {
 
     public static void main(String[] args) {
         try {
-            new Main().start();
+            Main main = new Main();
+            main.initialise();
+            main.run();
         } catch (Exception e) {
             e.printStackTrace();
         }

java/src/pm/application/Winamp/WinampApplication.java

@@ -2,8 +2,8 @@ package pm.application.Winamp;
 
 import pm.Action;
 import pm.Application;
-import pm.exception.ApplicationException;
+import pm.exception.application.ApplicationExitException;
-import pm.exception.application.ApplicationStartException;
+import pm.exception.application.ApplicationInitialiseException;
 
 import com.qotsa.exception.InvalidHandle;
 import com.qotsa.exception.InvalidParameter;
@@ -13,20 +13,24 @@ public class WinampApplication extends Application {
     protected boolean muted;
     protected int volume;
 
-    public void start() throws ApplicationException {
+    public void initialise() throws ApplicationInitialiseException {
         try {
             WinampController.run();
-            volume = WinampController.getVolume();
+            volume = 0; // UnsatisfiedLinkError: com.qotsa.jni.controller.JNIWinamp.getVolume()I
             muted = volume == 0;
         } catch (Exception e) {
-            throw new ApplicationStartException();
+            throw new ApplicationInitialiseException();
         }
     }
 
-    public void exit() {
+    public void exit() throws ApplicationExitException {
+        System.out.println("Exit WinampApplication");
+        super.exit();
         try {
-            WinampController.exit();
+            WinampController.exit(); // Todo: wachten totdat ook daadwerkelijk gestart? Anders crashed Winamp.
-        } catch (InvalidHandle e) {}
+        } catch (InvalidHandle e) {
+            throw new ApplicationExitException();
+        }
     }
 
     protected void action(Action action) {

java/src/pm/application/iTunes/iTunesApplication.java

@@ -2,6 +2,7 @@ package pm.application.iTunes;
 
 import pm.Action;
 import pm.Application;
+import pm.exception.application.ApplicationExitException;
 
 import com.dt.iTunesController.ITCOMDisabledReason;
 import com.dt.iTunesController.ITTrack;
@@ -20,14 +21,19 @@ public class iTunesApplication extends Application implements iTunesEventsInterf
         iTunes = new iTunes();
     }
 
-    public void start() throws Exception {
+    public void initialise() {
         iTunes.connect();
         iTunes.addEventHandler(this);
-        super.start();
     }
 
-    public void exit() {
+    public void exit() throws ApplicationExitException {
-        iTunes.quit();
+        System.out.println("Exit iTunesApplication");
+        super.exit();
+        try {
+            iTunes.quit(); // Todo: wachten totdat ook daadwerkelijk gestart? Anders wordt iTunes niet afgesloten.
+        } catch (Exception e) {
+            throw new ApplicationExitException();
+        }
     }
  
     protected void action(Action action) {

java/src/pm/device/Device.java

@@ -3,11 +3,13 @@ package pm.device;
 import pm.Action;
 import pm.Macro;
 import pm.exception.MacroException;
+import pm.exception.device.DeviceExitException;
+import pm.exception.device.DeviceInitialiseException;
 import pm.listener.ActionProvider;
 import pm.listener.MacroListener;
 import pm.macro.Event;
 
-public abstract class Device extends ActionProvider {
+public abstract class Device {
     protected MacroListener macroListener;
 
     public Device() {
@@ -26,6 +28,10 @@ public abstract class Device extends ActionProvider {
         macroListener.add(event);
     }
 
-    public void start() {}
+    public void add(Action action) {
-    public void exit() {}
+        ActionProvider.add(action);
+    }
+
+    public void initialise() throws DeviceInitialiseException {}
+    public void exit() throws DeviceExitException {}
 }

java/src/pm/device/example/ExampleDevice.java

@@ -5,7 +5,7 @@ import pm.Target;
 import pm.device.Device;
 
 public class ExampleDevice extends Device {
-    public void start() {
+    public void initialise() {
        //System.out.println("Ik hoef niets te starten");
        //addAction(Action.START, Target.APPLICATION);
        //addAction(Action.TEST, Target.APPLICATION);

java/src/pm/device/javainput/DirectionButton.java

@@ -4,7 +4,7 @@ import pm.Button;
 import pm.exception.event.UnknownDirectionException;
 import de.hardcode.jxinput.event.JXInputDirectionalEvent;
 
-public enum DirectionalSwitch implements Button {
+public enum DirectionButton implements Button {
     NORTH     (0),
     NORTHEAST (45),
     EAST      (90),
@@ -16,7 +16,7 @@ public enum DirectionalSwitch implements Button {
 
     protected int code;
 
-    private DirectionalSwitch(int code) {
+    private DirectionButton(int code) {
         this.code = code;
     }
 
@@ -24,8 +24,8 @@ public enum DirectionalSwitch implements Button {
         return code;
     }
 
-    public static DirectionalSwitch create(int angle) throws UnknownDirectionException  {
+    public static DirectionButton create(int angle) throws UnknownDirectionException  {
-        for (DirectionalSwitch button : DirectionalSwitch.values()) {
+        for (DirectionButton button : DirectionButton.values()) {
             if (button.getCode() == angle) {
                 return button;
             }
@@ -33,7 +33,7 @@ public enum DirectionalSwitch implements Button {
         throw new UnknownDirectionException();
     }
 
-    public static DirectionalSwitch create(JXInputDirectionalEvent event) throws UnknownDirectionException {
+    public static DirectionButton create(JXInputDirectionalEvent event) throws UnknownDirectionException {
         return create(event.getDirectional().getDirection() / 100);      
     }
 }

java/src/pm/device/javainput/JavaInputDevice.java

@@ -8,9 +8,9 @@ import de.hardcode.jxinput.event.JXInputDirectionalEvent;
 
 import pm.Button;
 import pm.device.Device;
-import pm.exception.DeviceException;
 import pm.exception.EventException;
-import pm.exception.device.JavaInputDeviceNotFoundException;
+import pm.exception.device.DeviceInitialiseException;
+import pm.exception.device.DeviceNotFoundException;
 import pm.macro.event.Press;
 import pm.macro.event.Release;
 
@@ -18,30 +18,19 @@ public abstract class JavaInputDevice extends Device {
     protected JavaInputListener javaInputListener;
     protected Button previousDirectionalButton;
 
-    protected JavaInputDevice(String name) throws DeviceException {
+    public void initialise(String name) throws DeviceInitialiseException {
-        super();
+        try {
             javaInputListener = new JavaInputListener(this, getDevice(name));
-   }
-
-    public void start() {
             javaInputListener.start();
+        } catch (DeviceNotFoundException e) {
+            throw new DeviceInitialiseException();
+        }        
     }
 
     public void exit() {
         javaInputListener.exit();
     }
 
-    public static JXInputDevice getDevice(String name) throws DeviceException {
-        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 JavaInputDeviceNotFoundException();
-    }
-
     public void processEvent(JXInputAxisEvent event) {
         //System.out.println(event);
     }
@@ -73,4 +62,15 @@ public abstract class JavaInputDevice extends Device {
 
     protected abstract Button getButton(JXInputButtonEvent event) throws EventException;
     protected abstract Button getButton(JXInputDirectionalEvent event) throws EventException;
+
+    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/src/pm/device/javainput/JavaInputListener.java

@@ -18,7 +18,7 @@ import de.hardcode.jxinput.event.JXInputDirectionalEvent;
 import de.hardcode.jxinput.event.JXInputDirectionalEventListener;
 import de.hardcode.jxinput.event.JXInputEventManager;
 
-public class JavaInputListener extends Thread implements JXInputAxisEventListener, JXInputButtonEventListener, JXInputDirectionalEventListener {
+public class JavaInputListener implements Runnable, JXInputAxisEventListener, JXInputButtonEventListener, JXInputDirectionalEventListener {
     protected static final int SLEEP = 100;
 
     protected boolean run;
@@ -70,6 +70,10 @@ public class JavaInputListener extends Thread implements JXInputAxisEventListene
         directionalEventQueue.add(event);        
     }
 
+    public void start() {
+        new Thread(this).start();
+    }
+
     public void run() {
         run = true;
         while (run) {

java/src/pm/device/javainput/extreme3d/Extreme3DDevice.java

@@ -1,30 +1,26 @@
 package pm.device.javainput.extreme3d;
 
-import de.hardcode.jxinput.event.JXInputButtonEvent;
-import de.hardcode.jxinput.event.JXInputDirectionalEvent;
 import pm.Action;
 import pm.Button;
 import pm.Macro;
 import pm.Target;
-import pm.device.javainput.DirectionalSwitch;
+import pm.device.javainput.DirectionButton;
 import pm.device.javainput.JavaInputDevice;
-import pm.exception.DeviceException;
 import pm.exception.MacroException;
+import pm.exception.device.DeviceInitialiseException;
 import pm.exception.event.UnknownButtonException;
 import pm.exception.event.UnknownDirectionException;
 import pm.macro.event.Hold;
 import pm.macro.event.Press;
 import pm.macro.event.Release;
+import de.hardcode.jxinput.event.JXInputButtonEvent;
+import de.hardcode.jxinput.event.JXInputDirectionalEvent;
 
 public class Extreme3DDevice extends JavaInputDevice {
     protected static final String NAME = "Logitech Extreme 3D";
 
-    public Extreme3DDevice() throws DeviceException {
+    public void initialise() throws DeviceInitialiseException {
-        super(NAME);
+        super.initialise(NAME);
-    }
-
-    public void start() {
-        super.start();
         try {
             add(
                 new Press(Extreme3DButton.TWELVE),
@@ -46,6 +42,6 @@ public class Extreme3DDevice extends JavaInputDevice {
     }
 
     protected Button getButton(JXInputDirectionalEvent event) throws UnknownDirectionException {
-        return DirectionalSwitch.create(event);
+        return DirectionButton.create(event);
     }
 }

java/src/pm/device/javainput/rumblepad/RumblepadDevice.java

@@ -2,12 +2,11 @@ package pm.device.javainput.rumblepad;
 
 import pm.Action;
 import pm.Button;
-import pm.Macro;
 import pm.Target;
-import pm.device.javainput.DirectionalSwitch;
+import pm.device.javainput.DirectionButton;
 import pm.device.javainput.JavaInputDevice;
-import pm.exception.DeviceException;
 import pm.exception.MacroException;
+import pm.exception.device.DeviceInitialiseException;
 import pm.exception.event.UnknownButtonException;
 import pm.exception.event.UnknownDirectionException;
 import pm.macro.event.Press;
@@ -15,15 +14,10 @@ import de.hardcode.jxinput.event.JXInputButtonEvent;
 import de.hardcode.jxinput.event.JXInputDirectionalEvent;
 
 public class RumblepadDevice extends JavaInputDevice {
-
     protected static final String NAME = "Logitech RumblePad 2 USB";
 
-    public RumblepadDevice() throws DeviceException {
+    public void initialise() throws DeviceInitialiseException {
-        super(NAME);
+        super.initialise(NAME);
-    }
-
-    public void start() {
-        super.start();
         try {
             add(
                 new Press(RumblepadButton.ONE),
@@ -62,6 +56,6 @@ public class RumblepadDevice extends JavaInputDevice {
     }
 
     protected Button getButton(JXInputDirectionalEvent event) throws UnknownDirectionException {
-        return DirectionalSwitch.create(event);
+        return DirectionButton.create(event);
     }
 }

java/src/pm/device/jintellitype/JIntellitypeDevice.java

@@ -11,6 +11,7 @@ import pm.Target;
 import pm.device.Device;
 import pm.exception.EventException;
 import pm.exception.MacroException;
+import pm.exception.device.DeviceInitialiseException;
 import pm.macro.event.Press;
 import pm.macro.event.Release;
 
@@ -24,13 +25,12 @@ public class JIntellitypeDevice extends Device implements HotkeyListener, Intell
         Hotkey.initialise(hotkeyList, jit);
     }
 
-    public void start() {
+    public void initialise() throws DeviceInitialiseException {
-        super.start();
         jit.addHotKeyListener(this);
         jit.addIntellitypeListener(this);
         try {
             add(
-                new Hotkey(HotkeyButton.CTRL, 'x'),
+                new Hotkey(HotkeyButton.CTRL | HotkeyButton.WIN, 'x'),
                 Action.EXIT.setTarget(Target.MAIN));
             add(
                 new Press(CommandButton.VOLUME_UP),

java/src/pm/device/textinput/TextinputDevice.java

@@ -15,7 +15,7 @@ public class TextinputDevice extends Device {
         run = true;
     }
     
-    public void start() {
+    public void initialise() {
         while(run) {
             String textinput = textinputScanner.next();
             if(textinput != null) {

java/src/pm/device/wiimote/WiimoteDevice.java

@@ -24,8 +24,8 @@ public class WiimoteDevice extends Device {
         wiimote = wiimoteService.getDevice(this);
     }
 
-    public void start() {
+    public void initialise() {
-        super.start();
+        super.initialise();
         try {
             add(
                 new Press(WiimoteButton.A),

java/src/pm/device/wiimote/WiimoteService.java

@@ -4,7 +4,7 @@ import java.util.ArrayList;
 import java.util.HashMap;
 
 import pm.exception.DeviceException;
-import pm.exception.device.JavaInputDeviceNotFoundException;
+import pm.exception.device.javainput.JavaInputDeviceSpecificException;
 import wiiusej.WiiUseApiManager;
 import wiiusej.Wiimote;
 import wiiusej.wiiusejevents.GenericEvent;
@@ -54,7 +54,7 @@ public class WiimoteService extends WiiUseApiManager implements WiimoteListener
                 return wiimote;
             }
         }
-        throw new JavaInputDeviceNotFoundException();
+        throw new JavaInputDeviceSpecificException();
     }
 
     public Wiimote getWiimote(GenericEvent event) {

java/src/pm/exception/application/ApplicationExitException.java

@@ -2,6 +2,6 @@ package pm.exception.application;
 
 import pm.exception.ApplicationException;
 
-public class ApplicationStartException extends ApplicationException {
+public class ApplicationExitException extends ApplicationException {
     protected static final long serialVersionUID = 1L;
 }

java/src/pm/exception/application/ApplicationInitialiseException.java

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

java/src/pm/exception/device/DeviceExitException.java

@@ -2,6 +2,6 @@ package pm.exception.device;
 
 import pm.exception.DeviceException;
 
-public class JavaInputDeviceNotFoundException extends DeviceException {
+public class DeviceExitException extends DeviceException {
     protected static final long serialVersionUID = 1L;
 }

java/src/pm/exception/device/DeviceInitialiseException.java

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

java/src/pm/exception/device/DeviceNotFoundException.java

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

java/src/pm/exception/device/JavaInputDeviceException.java

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

java/src/pm/exception/device/javainput/JavaInputDeviceSpecificException.java

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

java/src/pm/listener/ActionListener.java

@@ -13,24 +13,27 @@ public abstract class ActionListener implements Runnable {
 
     public ActionListener() {
         actionQueue = new ConcurrentLinkedQueue<Action>();
+        run = true;
     }
 
-    public void start() throws Exception {
+    public void start() {
         new Thread(this).start();
     }
 
     public void run() {
-        run = true;
         while (run) {
             if (actionQueue.isEmpty()) {
                 sleep(SLEEP);
             } else {
-                Action action = actionQueue.poll();
+                action(actionQueue.poll());
-                action(action);
             }
         }
     }
 
+    public void stop() {
+        run = false;
+    }
+
     public void add(Action action) {
         actionQueue.add(action);
     }

java/src/pm/listener/ActionProvider.java

@@ -11,8 +11,7 @@ public class ActionProvider {
         ActionProvider.actionQueue = actionQueue;        
     }
 
-    public void add(Action action) {
+    public static void add(Action action) {
-        System.out.println(action);
         actionQueue.add(action);
     }
 }

java/src/pm/listener/MacroListener.java

@@ -9,7 +9,7 @@ import pm.exception.MacroException;
 import pm.macro.Active;
 import pm.macro.Event;
 
-public class MacroListener extends ActionProvider {
+public class MacroListener {
     public ArrayList<Macro> macroList;
     public HashMap<Macro, Action> actionMap;
     public ArrayList<Active> activeList;
@@ -37,7 +37,7 @@ public class MacroListener extends ActionProvider {
         for (Active active : activeList) {
             if (active.next(event)) {
                 if (active.last()) {
-                    add(actionMap.get(active.getMacro()));
+                    ActionProvider.add(actionMap.get(active.getMacro()));
                     removeList.add(active);
                 }
             } else {

java/src/pm/util/ArrayCycle.java

@@ -22,7 +22,7 @@ public class ArrayCycle<E> extends ArrayList<E> {
         if (++index >= size()) {
             index = 0;
         }
-        return get(index);
+        return size() == 0 ? null : get(index);
     }
 
     public E reset() {