recovered merge/unmerge damage

app/build.gradle

@@ -44,7 +44,7 @@ android {
         minSdkVersion 21
         targetSdkVersion 23
         versionCode 1500
-        version "1.5g"
+        version "1.5g-combo-sandratest"
         buildConfigField "String", "VERSION", '"' + version + '"'
         buildConfigField "String", "BUILDVERSION", generateGitBuild()
     }

app/src/androidTest/java/ruffyscripter/RuffyScripterInstrumentedTest.java

@@ -44,7 +44,7 @@ public class RuffyScripterInstrumentedTest {
 
     private static Context appContext = InstrumentationRegistry.getTargetContext();
     private static ServiceConnection mRuffyServiceConnection;
-    private static RuffyScripter ruffyScripter;
+    private static RuffyScripter ruffyScripter = new RuffyScripter();
 
     @BeforeClass
     public static void bindRuffy() {
@@ -64,7 +64,7 @@ public class RuffyScripterInstrumentedTest {
 
             @Override
             public void onServiceConnected(ComponentName name, IBinder service) {
-                ruffyScripter = new RuffyScripter(IRuffyService.Stub.asInterface(service));
+                ruffyScripter.start(IRuffyService.Stub.asInterface(service));
                 log.debug("ruffy serivce connected");
             }
 

app/src/main/aidl/org/monkey/d/ruffy/ruffy/driver/IRTHandler.aidl

@@ -10,12 +10,17 @@ interface IRTHandler {
     void fail(String message);
 
     void requestBluetooth();
+    boolean canDisconnect();
     void rtStopped();
     void rtStarted();
 
     void rtClearDisplay();
     void rtUpdateDisplay(in byte[] quarter, int which);
 
-    void rtDisplayHandleMenu(in Menu menu);
+    void rtDisplayHandleMenu(in Menu menu, in int sequence);
-    void rtDisplayHandleNoMenu();
+    void rtDisplayHandleNoMenu(in int sequence);
+
+    void keySent(in int sequence);
+
+    String getServiceIdentifier();
 }

app/src/main/aidl/org/monkey/d/ruffy/ruffy/driver/IRuffyService.aidl

@@ -13,10 +13,10 @@ interface IRuffyService {
     *
     * @return 0 if successful, -1 otherwise
     */
-    int doRTConnect();
+    int doRTConnect(IRTHandler handler);
 
     /** Disconnect from the pump */
-    void doRTDisconnect();
+    void doRTDisconnect(IRTHandler handler);
 
     /*What's the meaning of 'changed'?
      * changed means if a button state has been changed, like btton pressed is a change and button release another*/

app/src/main/java/de/jotomo/ruffyscripter/RuffyScripter.java

@@ -1,6 +1,5 @@
 package de.jotomo.ruffyscripter;
 
-import android.os.DeadObjectException;
 import android.os.RemoteException;
 import android.os.SystemClock;
 
@@ -35,7 +34,7 @@ public class RuffyScripter {
     private static final Logger log = LoggerFactory.getLogger(RuffyScripter.class);
 
 
-    private final IRuffyService ruffyService;
+    private IRuffyService ruffyService;
     private final long connectionTimeOutMs = 5000;
     private String unrecoverableError = null;
 
@@ -50,27 +49,41 @@ public class RuffyScripter {
 
     private boolean started = false;
 
-    public RuffyScripter(final IRuffyService ruffyService) {
+    private final Object keylock = new Object();
-        this.ruffyService = ruffyService;
+    private int keynotwait = 0;
+
+    private final Object screenlock = new Object();
+
+    public RuffyScripter() {
+
     }
 
-    public void start() {
+    public void start(IRuffyService newService) {
         try {
-            ruffyService.addHandler(mHandler);
+            if(newService!=null) {
-            idleDisconnectMonitorThread.start();
+                this.ruffyService = newService;
-            started = true;
+                // TODO this'll be done better in v2 via ConnectionManager
-        } catch (RemoteException e) {
+                if (idleDisconnectMonitorThread.getState() == Thread.State.NEW) {
+                    idleDisconnectMonitorThread.start();
+                }
+                started = true;
+                try{newService.addHandler(mHandler);}catch (Exception e){}
+            }
+        } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }
 
     public void stop() {
         if (started) {
-            try {
+            started=false;
+            // TODO ruffy removes dead handlers automatically by now.
+            // still, check this when going through recovery logic
+/*            try {
                 ruffyService.removeHandler(mHandler);
             } catch (RemoteException e) {
                 log.warn("Removing IRTHandler from Ruffy service failed, ignoring", e);
-            }
+            }*/
         }
     }
 
@@ -78,6 +91,7 @@ public class RuffyScripter {
         return started;
     }
 
+    private boolean canDisconnect = false;
     private Thread idleDisconnectMonitorThread = new Thread(new Runnable() {
         @Override
         public void run() {
@@ -91,20 +105,24 @@ public class RuffyScripter {
                             && now > lastDisconnect + 15 * 1000) {
                         log.debug("Disconnecting after " + (connectionTimeOutMs / 1000) + "s inactivity timeout");
                         lastDisconnect = now;
-                        ruffyService.doRTDisconnect();
+                        canDisconnect=true;
+                        ruffyService.doRTDisconnect(mHandler);
                         connected = false;
                         lastDisconnect = System.currentTimeMillis();
                         // don't attempt anything fancy in the next 10s, let the pump settle
                         SystemClock.sleep(10 * 1000);
                     }
-                } catch (DeadObjectException doe) {
+                    else
+                    {
+                        canDisconnect=false;
+                    }
+                } catch (Exception e) {
                     // TODO do we need to catch this exception somewhere else too? right now it's
                     // converted into a command failure, but it's not classified as unrecoverable;
                     // eventually we might try to recover ... check docs, there's also another
                     // execption we should watch interacting with a remote service.
                     // SecurityException was the other, when there's an AIDL mismatch;
-                    unrecoverableError = "Ruffy service went away";
+                    //unrecoverableError = "Ruffy service went away";
-                } catch (RemoteException e) {
                     log.debug("Exception in idle disconnect monitor thread, carrying on", e);
                 }
                 SystemClock.sleep(1000);
@@ -128,6 +146,11 @@ public class RuffyScripter {
             log.trace("Ruffy invoked requestBluetooth callback");
         }
 
+        @Override
+        public boolean canDisconnect() throws RemoteException {
+            return canDisconnect;
+        }
+
         @Override
         public void rtStopped() throws RemoteException {
             log.debug("rtStopped callback invoked");
@@ -150,13 +173,18 @@ public class RuffyScripter {
         }
 
         @Override
-        public void rtDisplayHandleMenu(Menu menu) throws RemoteException {
+        public void rtDisplayHandleMenu(Menu menu, int sequence) throws RemoteException {
             // method is called every ~500ms
             log.debug("rtDisplayHandleMenu: " + menu.getType());
 
             currentMenu = menu;
             menuLastUpdated = System.currentTimeMillis();
 
+            synchronized (screenlock)
+            {
+                screenlock.notifyAll();
+            }
+
             connected = true;
 
             // note that a WARNING_OR_ERROR menu can be a valid temporary state (cancelling TBR)
@@ -167,16 +195,39 @@ public class RuffyScripter {
         }
 
         @Override
-        public void rtDisplayHandleNoMenu() throws RemoteException {
+        public void rtDisplayHandleNoMenu(int sequence) throws RemoteException {
             log.debug("rtDisplayHandleNoMenu callback invoked");
         }
 
+
+        @Override
+        public void keySent(int sequence) throws RemoteException {
+            synchronized (keylock)
+            {
+                if(keynotwait>0)
+                    keynotwait--;
+                else
+                    keylock.notify();
+            }
+        }
+
+        @Override
+        public String getServiceIdentifier() throws RemoteException {
+            return this.toString();
+        }
+
     };
 
     public boolean isPumpBusy() {
         return activeCmd != null;
     }
 
+    public void unbind() {
+        if(ruffyService!=null)
+            try{ruffyService.removeHandler(mHandler);}catch (Exception e){}
+        this.ruffyService = null;
+    }
+
     private static class Returnable {
         CommandResult cmdResult;
     }
@@ -324,7 +375,8 @@ public class RuffyScripter {
                 SystemClock.sleep(10 * 1000);
             }
 
-            boolean connectInitSuccessful = ruffyService.doRTConnect() == 0;
+            canDisconnect=false;
+            boolean connectInitSuccessful = ruffyService.doRTConnect(mHandler) == 0;
             log.debug("Connect init successful: " + connectInitSuccessful);
             log.debug("Waiting for first menu update to be sent");
             // Note: there was an 'if(currentMenu == null)' around the next call, since
@@ -337,7 +389,7 @@ public class RuffyScripter {
             // before a connection is possible. In that case, it takes 45s before the
             // connection comes up.
             waitForMenuUpdate(90);
-        } catch (RemoteException e) {
+        } catch (Exception e) {
             throw new CommandException().exception(e).message("Unexpected exception while initiating/restoring pump connection");
         }
     }
@@ -347,38 +399,95 @@ public class RuffyScripter {
     // so this class can focus on providing a connection to run commands
     // (or maybe reconsider putting it into a base class)
 
-    private static class Key {
+    public static class Key {
-        static byte NO_KEY = (byte) 0x00;
+        public static byte NO_KEY = (byte) 0x00;
-        static byte MENU = (byte) 0x03;
+        public static byte MENU = (byte) 0x03;
-        static byte CHECK = (byte) 0x0C;
+        public static byte CHECK = (byte) 0x0C;
-        static byte UP = (byte) 0x30;
+        public static byte UP = (byte) 0x30;
-        static byte DOWN = (byte) 0xC0;
+        public static byte DOWN = (byte) 0xC0;
+        public static byte BACK = (byte) 0x33;
     }
 
     public void pressUpKey() {
         log.debug("Pressing up key");
-        pressKey(Key.UP);
+        pressKey(Key.UP,2000);
         log.debug("Releasing up key");
     }
 
     public void pressDownKey() {
         log.debug("Pressing down key");
-        pressKey(Key.DOWN);
+        pressKey(Key.DOWN,2000);
         log.debug("Releasing down key");
     }
 
     public void pressCheckKey() {
         log.debug("Pressing check key");
-        pressKey(Key.CHECK);
+        pressKey(Key.CHECK,2000);
         log.debug("Releasing check key");
     }
 
     public void pressMenuKey() {
         log.debug("Pressing menu key");
-        pressKey(Key.MENU);
+        pressKey(Key.MENU,2000);
         log.debug("Releasing menu key");
     }
 
+    public void pressBackKey() {
+        log.debug("Pressing back key");
+        pressKey(Key.BACK,2000);
+        log.debug("Releasing back key");
+    }
+
+    public boolean waitScreen(long timeout)
+    {
+        synchronized (screenlock) {
+            try {
+                screenlock.wait(timeout);
+            } catch (Exception e) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean goToMainMenuScreen(MenuType screen, long timeout)
+    {
+        long start = System.currentTimeMillis();
+        while((currentMenu == null || currentMenu.getType()!=screen) && start+timeout>System.currentTimeMillis())
+        {
+            if(currentMenu!=null && currentMenu.getType()==MenuType.WARNING_OR_ERROR)
+            {
+                //FIXME bad thing to do :D
+                pressCheckKey();
+            }
+            else if(currentMenu!=null && !currentMenu.getType().isMaintype())
+            {
+                pressBackKey();
+            }
+            else
+                pressMenuKey();
+            waitScreen(250);
+        }
+        return currentMenu != null && currentMenu.getType()==screen;
+    }
+
+    public boolean enterMenu(MenuType startType, MenuType targetType, byte key, long timeout)
+    {
+        if(currentMenu==null || currentMenu.getType() != startType)
+            return false;
+        long start = System.currentTimeMillis();
+        pressKey(key,2000);
+        while((currentMenu == null || currentMenu.getType()!=targetType) && start+timeout>System.currentTimeMillis()) {
+            waitScreen(100);
+        }
+        return currentMenu!=null && currentMenu.getType()==targetType;
+    }
+
+    public void step(int steps, byte key, long timeout) {
+        for(int i = 0; i < Math.abs(steps);i++)
+            pressKey(key,timeout);
+    }
+
     // TODO v2, rework these two methods: waitForMenuUpdate shoud only be used by commands
     // then anything longer than a few seconds is an error;
     // only ensureConnected() uses the method with the timeout parameter; inline that code,
@@ -401,12 +510,26 @@ public class RuffyScripter {
         }
     }
 
-    private void pressKey(final byte key) {
+    private void pressKey(final byte key, long timeout) {
         try {
             ruffyService.rtSendKey(key, true);
-            SystemClock.sleep(100);
+            //SystemClock.sleep(200);
             ruffyService.rtSendKey(Key.NO_KEY, true);
-        } catch (RemoteException e) {
+            if(timeout > 0)
+            {
+                synchronized (keylock)
+                {
+                    keylock.wait(timeout);
+                }
+            }
+            else
+            {
+                synchronized (keylock)
+                {
+                    keynotwait++;
+                }
+            }
+        } catch (Exception e) {
             throw new CommandException().exception(e).message("Error while pressing buttons");
         }
     }

app/src/main/java/de/jotomo/ruffyscripter/commands/GetBasalCommand.java

@@ -0,0 +1,191 @@
+package de.jotomo.ruffyscripter.commands;
+
+import android.util.Log;
+
+import org.monkey.d.ruffy.ruffy.driver.display.MenuAttribute;
+import org.monkey.d.ruffy.ruffy.driver.display.MenuType;
+import org.monkey.d.ruffy.ruffy.driver.display.menu.MenuTime;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+
+import de.jotomo.ruffyscripter.PumpState;
+import de.jotomo.ruffyscripter.RuffyScripter;
+
+import static de.jotomo.ruffyscripter.commands.GetBasalCommand.State.BEFORE;
+import static de.jotomo.ruffyscripter.commands.GetBasalCommand.State.MAIN;
+import static de.jotomo.ruffyscripter.commands.GetBasalCommand.State.BASAL_1_MENU;
+import static de.jotomo.ruffyscripter.commands.GetBasalCommand.State.BASAL_OVERVIEW;
+import static de.jotomo.ruffyscripter.commands.GetBasalCommand.State.READ_BASAL;
+import static de.jotomo.ruffyscripter.commands.GetBasalCommand.State.ERROR;
+import static de.jotomo.ruffyscripter.commands.GetBasalCommand.State.AFTER;
+
+public class GetBasalCommand implements Command {
+    private static final Logger log = LoggerFactory.getLogger(GetBasalCommand.class);
+
+    private RuffyScripter scripter;
+
+    public GetBasalCommand() {}
+
+    @Override
+    public List<String> validateArguments() {
+        List<String> violations = new ArrayList<>();
+
+        return violations;
+    }
+
+    enum State {
+        BEFORE,
+        MAIN,
+        BASAL_1_MENU,
+        BASAL_OVERVIEW,
+        READ_BASAL,
+        ERROR,
+        AFTER,
+    };
+    private State lastState,state;
+    private long last;
+    private long timeout;
+    private Thread timeoutThread = new Thread()
+    {
+        @Override
+        public void run() {
+            while(state != ERROR && state!=AFTER) {
+                if (timeout + last < System.currentTimeMillis()) {
+                    lastState = state;
+                    state = ERROR;
+                    log.debug("timeout reached -> state:ERROR");
+                }
+                tick();
+                try {
+                    Thread.sleep(100);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+            tick();
+        }
+    };
+    private void updateState(State newState,long timeoutSec)
+    {
+        lastState = state;
+        state = newState;
+        last = System.currentTimeMillis();
+        timeout = timeoutSec*1000;
+    }
+    private MenuType lastMenu;
+    private int retries = 0;
+    private double basalTotal = 0;
+    private Map<Integer,Double> rate = new HashMap<>();
+
+    private void tick()
+    {
+        switch (state)
+        {
+            case BEFORE:
+                if(scripter.currentMenu!=null && scripter.currentMenu.getType()==MenuType.MAIN_MENU)
+                {
+                    updateState(MAIN,120);
+                    lastMenu = MenuType.MAIN_MENU;
+                    log.debug("found MAIN_MENU -> state:MAIN");
+                    retries=3;
+                }
+                break;
+            case MAIN:
+                if(retries>0)
+                    if(scripter.goToMainMenuScreen(MenuType.BASAL_1_MENU,30000))
+                    {
+                        if(scripter.enterMenu(MenuType.BASAL_1_MENU,MenuType.BASAL_TOTAL, RuffyScripter.Key.CHECK,2000))
+                        {
+                            updateState(BASAL_OVERVIEW, 30);
+                            retries=0;
+                        }
+                    }
+                    else
+                        retries--;
+                else
+                    updateState(ERROR,30);
+                break;
+            case BASAL_OVERVIEW:
+                if(scripter.currentMenu.getType()==MenuType.BASAL_TOTAL && scripter.currentMenu.getAttribute(MenuAttribute.BASAL_TOTAL)!=null && (Integer)scripter.currentMenu.getAttribute(MenuAttribute.BASAL_SELECTED)==1)
+                {
+                    basalTotal = (Double)scripter.currentMenu.getAttribute(MenuAttribute.BASAL_TOTAL);
+                    if(scripter.enterMenu(MenuType.BASAL_TOTAL,MenuType.BASAL_SET, RuffyScripter.Key.MENU,3000))
+                    {
+                        updateState(READ_BASAL,30);
+                        retries = 96;
+                    }
+                }
+                break;
+            case READ_BASAL:
+                if(scripter.currentMenu.getType()==MenuType.BASAL_SET && scripter.currentMenu.getAttribute(MenuAttribute.BASAL_START)!=null) {
+                    Object rateObj = scripter.currentMenu.getAttribute(MenuAttribute.BASAL_RATE);
+                    MenuTime time = (MenuTime) scripter.currentMenu.getAttribute(MenuAttribute.BASAL_START);
+                    if (rateObj instanceof Double) {
+                        rate.put(time.getHour(), (Double) rateObj);
+                    }
+                    boolean complete = true;
+                    for (int t = 0; t < 24; t++) {
+                        if (rate.get(t) == null)
+                            complete = false;
+                    }
+                    if (retries > 0) {
+                        if (complete) {
+                            scripter.pressBackKey();
+                            updateState(AFTER, 30);
+                        } else {
+                            retries--;
+                            scripter.pressMenuKey();
+                            scripter.waitScreen(250);
+                        }
+                    } else {
+                        updateState(ERROR, 30);
+                    }
+                }
+                break;
+            case ERROR:
+            case AFTER:
+                scripter.goToMainMenuScreen(MenuType.MAIN_MENU,2000);
+                synchronized(GetBasalCommand.this) {
+                    GetBasalCommand.this.notify();
+                }
+                break;
+        }
+    }
+    @Override
+    public CommandResult execute(RuffyScripter scripter, PumpState initialPumpState) {
+            state = BEFORE;
+            this.scripter = scripter;
+            updateState(BEFORE,120);
+            timeoutThread.start();
+
+            try {
+                synchronized (this) {
+                    this.wait();
+                }
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+                return new CommandResult().success(false).message("failed to wait: "+e.getMessage());
+            }
+            if(state==AFTER)
+            {
+                for(int i = 0; i < 24;i++)
+                {
+                    Log.v("BASAL_RATE","BASAL_RATE from "+String.format("%02d",i)+":00 = "+rate.get(i));
+                }
+                return new CommandResult().success(true).enacted(true).message("Basal Rate was read");
+            }
+            return new CommandResult().success(false).message("failed with state: "+state+" from: "+lastState);
+    }
+
+    @Override
+    public String toString() {
+        return "GetTbrCommand{}";
+    }
+}

app/src/main/java/de/jotomo/ruffyscripter/commands/SetTbrCommand.java

@@ -1,6 +1,5 @@
 package de.jotomo.ruffyscripter.commands;
 
-import android.os.SystemClock;
 import android.util.Log;
 
 import org.monkey.d.ruffy.ruffy.driver.display.MenuAttribute;
@@ -16,11 +15,22 @@ import java.util.Locale;
 import de.jotomo.ruffyscripter.PumpState;
 import de.jotomo.ruffyscripter.RuffyScripter;
 
+import static de.jotomo.ruffyscripter.commands.SetTbrCommand.State.AFTER;
+import static de.jotomo.ruffyscripter.commands.SetTbrCommand.State.BEFORE;
+import static de.jotomo.ruffyscripter.commands.SetTbrCommand.State.ERROR;
+import static de.jotomo.ruffyscripter.commands.SetTbrCommand.State.MAIN;
+import static de.jotomo.ruffyscripter.commands.SetTbrCommand.State.SET;
+import static de.jotomo.ruffyscripter.commands.SetTbrCommand.State.SET_TBR;
+import static de.jotomo.ruffyscripter.commands.SetTbrCommand.State.SET_TIME;
+import static de.jotomo.ruffyscripter.commands.SetTbrCommand.State.TBR;
+import static de.jotomo.ruffyscripter.commands.SetTbrCommand.State.TIME;
+
 public class SetTbrCommand implements Command {
     private static final Logger log = LoggerFactory.getLogger(SetTbrCommand.class);
 
     private final long percentage;
     private final long duration;
+    private RuffyScripter scripter;
 
     public SetTbrCommand(long percentage, long duration) {
         this.percentage = percentage;
@@ -54,70 +64,47 @@ public class SetTbrCommand implements Command {
         return violations;
     }
 
-    @Override
+    enum State {
-    public CommandResult execute(RuffyScripter scripter, PumpState initialPumpState) {
+        BEFORE,
-        try {
+        MAIN,
-            enterTbrMenu(scripter);
+        TBR,
-            inputTbrPercentage(scripter);
+        SET_TBR,
-            verifyDisplayedTbrPercentage(scripter);
+        TIME,
-
+        SET_TIME,
-            if (percentage == 100) {
+        SET,
-                cancelTbrAndConfirmCancellationWarning(scripter);
+        AFTER,
-            } else {
+        ERROR
-                // switch to TBR_DURATION menu by pressing menu key
+    };
-                scripter.verifyMenuIsDisplayed(MenuType.TBR_SET);
+    private State lastState,state;
-                scripter.pressMenuKey();
+    private long last;
-                scripter.waitForMenuUpdate();
+    private long timeout;
-                scripter.verifyMenuIsDisplayed(MenuType.TBR_DURATION);
+    private Thread timeoutThread = new Thread()
-
+    {
-                inputTbrDuration(scripter);
+        @Override
-                verifyDisplayedTbrDuration(scripter);
+        public void run() {
-
+            while(state != ERROR && state!=AFTER) {
-                // confirm TBR
+                if (timeout + last < System.currentTimeMillis()) {
-                scripter.pressCheckKey();
+                    lastState = state;
-                scripter.waitForMenuToBeLeft(MenuType.TBR_DURATION);
+                    state = ERROR;
+                    log.debug("timeout reached -> state:ERROR");
+                }
+                tick();
+                try {
+                    Thread.sleep(100);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
             }
-
+            tick();
-            scripter.verifyMenuIsDisplayed(MenuType.MAIN_MENU,
-                    "Pump did not return to MAIN_MEU after setting TBR. " +
-                            "Check pump manually, the TBR might not have been set/cancelled.");
-
-            // check main menu shows the same values we just set
-            if (percentage == 100) {
-                verifyMainMenuShowsNoActiveTbr(scripter);
-                return new CommandResult().success(true).enacted(true).message("TBR was cancelled");
-            } else {
-                verifyMainMenuShowsExpectedTbrActive(scripter);
-                return new CommandResult().success(true).enacted(true).message(
-                        String.format(Locale.US, "TBR set to %d%% for %d min", percentage, duration));
-            }
-
-        } catch (CommandException e) {
-            return e.toCommandResult();
         }
+    };
+    private void updateState(State newState,long timeoutSec)
+    {
+        lastState = state;
+        state = newState;
+        last = System.currentTimeMillis();
+        timeout = timeoutSec*1000;
     }
-<<<<<<< HEAD
-
-    private void enterTbrMenu(RuffyScripter scripter) {
-        scripter.verifyMenuIsDisplayed(MenuType.MAIN_MENU);
-        scripter.navigateToMenu(MenuType.TBR_MENU);
-        scripter.verifyMenuIsDisplayed(MenuType.TBR_MENU);
-        scripter.pressCheckKey();
-        scripter.waitForMenuUpdate();
-        scripter.verifyMenuIsDisplayed(MenuType.TBR_SET);
-    }
-
-    private void inputTbrPercentage(RuffyScripter scripter) {
-        scripter.verifyMenuIsDisplayed(MenuType.TBR_SET);
-        long currentPercent = readDisplayedTbrPercentage(scripter);
-        log.debug("Current TBR %: " + currentPercent);
-        long percentageChange = percentage - currentPercent;
-        long percentageSteps = percentageChange / 10;
-        boolean increasePercentage = true;
-        if (percentageSteps < 0) {
-            increasePercentage = false;
-            percentageSteps = Math.abs(percentageSteps);
-=======
     private MenuType lastMenu;
     private int retries = 0;
     private void tick()
@@ -144,7 +131,10 @@ public class SetTbrCommand implements Command {
                     else
                         retries--;
                 else
+                {
+                    Log.v("SetTbrCommand:tick",state+": no retries left for adjusting basals");
                     updateState(ERROR,30);
+                }
                 break;
             case TBR:
                 if(scripter.enterMenu(MenuType.TBR_MENU,MenuType.TBR_SET, RuffyScripter.Key.CHECK,20000))
@@ -153,7 +143,10 @@ public class SetTbrCommand implements Command {
                     retries = 10;
                 }
                 else
+                {
+                    Log.v("SetTbrCommand:tick",state+": no retries left for adjusting basals");
                     updateState(ERROR,30);
+                }
                 break;
             case SET_TBR:
                 if(scripter.currentMenu!=null && scripter.currentMenu.getType()==MenuType.TBR_SET)
@@ -217,8 +210,8 @@ public class SetTbrCommand implements Command {
                 }
                 else
                 {
-                    Log.v("SetTbrCommand:tick",state+": next retry "+retries+"left");
                     retries--;
+                    Log.v("SetTbrCommand:tick",state+": next retry "+retries+"left");
                 }
                 break;
             case SET_TIME:
@@ -271,6 +264,7 @@ public class SetTbrCommand implements Command {
                                 Log.v("SetTbrCommand:tick",state+": no retry left");
                                 updateState(ERROR,30);
                             }
+
                         }
                     }
                 }
@@ -297,7 +291,6 @@ public class SetTbrCommand implements Command {
                     Object setPercentage = scripter.currentMenu.getAttribute(MenuAttribute.TBR);
                     Object setDuration = scripter.currentMenu.getAttribute(MenuAttribute.RUNTIME);
                     Log.v("SetTbrCommand:tick",state+": got percentage: "+setPercentage+" requestes: "+percentage+" duration: "+setDuration+" request: "+duration);
-
                     if (setPercentage== null ||setDuration==null) {
                         if(percentage!=100)
                         {
@@ -336,182 +329,32 @@ public class SetTbrCommand implements Command {
                     SetTbrCommand.this.notify();
                 }
                 break;
->>>>>>> add Logs to setTbrCommand
-        }
-        log.debug("Pressing " + (increasePercentage ? "up" : "down") + " " + percentageSteps + " times");
-        for (int i = 0; i < percentageSteps; i++) {
-            scripter.verifyMenuIsDisplayed(MenuType.TBR_SET);
-            if (increasePercentage) scripter.pressUpKey();
-            else scripter.pressDownKey();
-            SystemClock.sleep(100);
-            log.debug("Push #" + (i + 1));
-        }
-        // Give the pump time to finish any scrolling that might still be going on, can take
-        // up to 1100ms. Plus some extra time to be sure
-        SystemClock.sleep(2000);
-    }
-
-    private void verifyDisplayedTbrPercentage(RuffyScripter scripter) {
-        scripter.verifyMenuIsDisplayed(MenuType.TBR_SET);
-        long displayedPercentage = readDisplayedTbrPercentage(scripter);
-        if (displayedPercentage != percentage) {
-            log.debug("Final displayed TBR percentage: " + displayedPercentage);
-            throw new CommandException().message("Failed to set TBR percentage");
-        }
-
-        // check again to ensure the displayed value hasn't change due to due scrolling taking extremely long
-        SystemClock.sleep(2000);
-        long refreshedDisplayedTbrPecentage = readDisplayedTbrPercentage(scripter);
-        if (displayedPercentage != refreshedDisplayedTbrPecentage) {
-            throw new CommandException().message("Failed to set TBR percentage: " +
-                    "percentage changed after input stopped from "
-                    + displayedPercentage + " -> " + refreshedDisplayedTbrPecentage);
         }
     }
+    @Override
+    public CommandResult execute(RuffyScripter scripter, PumpState initialPumpState) {
+        state = BEFORE;
+        this.scripter = scripter;
+        updateState(BEFORE,120);
+        timeoutThread.start();
 
-    private long readDisplayedTbrPercentage(RuffyScripter scripter) {
+        try {
-        // TODO v2 add timeout? Currently the command execution timeout would trigger if exceeded
+            synchronized (this) {
-        Object percentageObj = scripter.currentMenu.getAttribute(MenuAttribute.BASAL_RATE);
+                this.wait();
-        // this as a bit hacky, the display value is blinking, so we might catch that, so
-        // keep trying till we get the Double we want
-        while (!(percentageObj instanceof Double)) {
-            scripter.waitForMenuUpdate();
-            percentageObj = scripter.currentMenu.getAttribute(MenuAttribute.BASAL_RATE);
-        }
-        return ((Double) percentageObj).longValue();
-    }
-
-    private void inputTbrDuration(RuffyScripter scripter) {
-        scripter.verifyMenuIsDisplayed(MenuType.TBR_DURATION);
-        long currentDuration = readDisplayedTbrDuration(scripter);
-        if (currentDuration % 15 != 0) {
-            // The duration displayed is how long an active TBR will still run,
-            // which might be something like 0:13, hence not in 15 minute steps.
-            // Pressing up will go to the next higher 15 minute step.
-            // Don't press down, from 0:13 it can't go down, so press up.
-            // Pressing up from 23:59 works to go to 24:00.
-            scripter.verifyMenuIsDisplayed(MenuType.TBR_DURATION);
-            scripter.pressUpKey();
-            scripter.waitForMenuUpdate();
-            currentDuration = readDisplayedTbrDuration(scripter);
-        }
-        log.debug("Current TBR duration: " + currentDuration);
-        long durationChange = duration - currentDuration;
-        long durationSteps = durationChange / 15;
-        boolean increaseDuration = true;
-        if (durationSteps < 0) {
-            increaseDuration = false;
-            durationSteps = Math.abs(durationSteps);
-        }
-        log.debug("Pressing " + (increaseDuration ? "up" : "down") + " " + durationSteps + " times");
-        for (int i = 0; i < durationSteps; i++) {
-            scripter.verifyMenuIsDisplayed(MenuType.TBR_DURATION);
-            if (increaseDuration) scripter.pressUpKey();
-            else scripter.pressDownKey();
-            SystemClock.sleep(100);
-            log.debug("Push #" + (i + 1));
-        }
-        // Give the pump time to finish any scrolling that might still be going on, can take
-        // up to 1100ms. Plus some extra time to be sure
-        SystemClock.sleep(2000);
-    }
-
-    private void verifyDisplayedTbrDuration(RuffyScripter scripter) {
-        scripter.verifyMenuIsDisplayed(MenuType.TBR_DURATION);
-        long displayedDuration = readDisplayedTbrDuration(scripter);
-        if (displayedDuration != duration) {
-            log.debug("Final displayed TBR duration: " + displayedDuration);
-            throw new CommandException().message("Failed to set TBR duration");
-        }
-
-        // check again to ensure the displayed value hasn't change due to due scrolling taking extremely long
-        SystemClock.sleep(2000);
-        long refreshedDisplayedTbrDuration = readDisplayedTbrDuration(scripter);
-        if (displayedDuration != refreshedDisplayedTbrDuration) {
-            throw new CommandException().message("Failed to set TBR duration: " +
-                    "duration changed after input stopped from "
-                    + displayedDuration + " -> " + refreshedDisplayedTbrDuration);
-        }
-    }
-
-    private long readDisplayedTbrDuration(RuffyScripter scripter) {
-        // TODO v2 add timeout? Currently the command execution timeout would trigger if exceeded
-        scripter.verifyMenuIsDisplayed(MenuType.TBR_DURATION);
-        Object durationObj = scripter.currentMenu.getAttribute(MenuAttribute.RUNTIME);
-        // this as a bit hacky, the display value is blinking, so we might catch that, so
-        // keep trying till we get the Double we want
-        while (!(durationObj instanceof MenuTime)) {
-            scripter.waitForMenuUpdate();
-            durationObj = scripter.currentMenu.getAttribute(MenuAttribute.RUNTIME);
-        }
-        MenuTime duration = (MenuTime) durationObj;
-        return duration.getHour() * 60 + duration.getMinute();
-    }
-
-    private void cancelTbrAndConfirmCancellationWarning(RuffyScripter scripter) {
-        // confirm entered TBR
-        scripter.verifyMenuIsDisplayed(MenuType.TBR_SET);
-        scripter.pressCheckKey();
-
-        // A "TBR CANCELLED alert" is only raised by the pump when the remaining time is
-        // greater than 60s (displayed as 0:01, the pump goes from there to finished.
-        // We could read the remaining duration from MAIN_MENU, but by the time we're here,
-        // the pumup could have moved from 0:02 to 0:01, so instead, check if a "TBR CANCELLED" alert
-        // is raised and if so dismiss it
-        long inFiveSeconds = System.currentTimeMillis() + 5 * 1000;
-        boolean alertProcessed = false;
-        while (System.currentTimeMillis() < inFiveSeconds && !alertProcessed) {
-            if (scripter.currentMenu.getType() == MenuType.WARNING_OR_ERROR) {
-                // Check the raised alarm is TBR CANCELLED, so we're not accidentally cancelling
-                // a different alarm that might be raised at the same time.
-                // Note that the message is permanently displayed, while the error code is blinking.
-                // A wait till the error code can be read results in the code hanging, despite
-                // menu updates coming in, so just check the message.
-                // TODO v2 this only works when the pump's language is English
-                String errorMsg = (String) scripter.currentMenu.getAttribute(MenuAttribute.MESSAGE);
-                if (!errorMsg.equals("TBR CANCELLED")) {
-                    throw new CommandException().success(false).enacted(false)
-                            .message("An alert other than the expected TBR CANCELLED was raised by the pump: "
-                                    + errorMsg + ". Please check the pump.");
-                }
-                // confirm "TBR CANCELLED" alert
-                scripter.verifyMenuIsDisplayed(MenuType.WARNING_OR_ERROR);
-                scripter.pressCheckKey();
-                // dismiss "TBR CANCELLED" alert
-                scripter.verifyMenuIsDisplayed(MenuType.WARNING_OR_ERROR);
-                scripter.pressCheckKey();
-                scripter.waitForMenuToBeLeft(MenuType.WARNING_OR_ERROR);
-                alertProcessed = true;
             }
-            SystemClock.sleep(10);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+            return new CommandResult().success(false).message("failed to wait: "+e.getMessage());
         }
-    }
+        if(state==AFTER)
+        {
+            if(percentage==100)
+                return new CommandResult().success(true).enacted(true).message("TBR was cancelled");
 
-    private void verifyMainMenuShowsNoActiveTbr(RuffyScripter scripter) {
+            return new CommandResult().success(true).enacted(true).message(
-        scripter.verifyMenuIsDisplayed(MenuType.MAIN_MENU);
+                    String.format(Locale.US, "TBR set to %d%% for %d min", percentage, duration));
-        Double tbrPercentage = (Double) scripter.currentMenu.getAttribute(MenuAttribute.TBR);
-        boolean runtimeDisplayed = scripter.currentMenu.attributes().contains(MenuAttribute.RUNTIME);
-        if (tbrPercentage != 100 || runtimeDisplayed) {
-            throw new CommandException().message("Cancelling TBR failed, TBR is still set according to MAIN_MENU");
-        }
-    }
-
-    private void verifyMainMenuShowsExpectedTbrActive(RuffyScripter scripter) {
-        scripter.verifyMenuIsDisplayed(MenuType.MAIN_MENU);
-        // new TBR set; percentage and duration must be displayed ...
-        if (!scripter.currentMenu.attributes().contains(MenuAttribute.TBR) ||
-                !scripter.currentMenu.attributes().contains(MenuAttribute.RUNTIME)) {
-            throw new CommandException().message("Setting TBR failed, according to MAIN_MENU no TBR is active");
-        }
-        Double mmTbrPercentage = (Double) scripter.currentMenu.getAttribute(MenuAttribute.TBR);
-        MenuTime mmTbrDuration = (MenuTime) scripter.currentMenu.getAttribute(MenuAttribute.RUNTIME);
-        // ... and be the same as what we set
-        // note that displayed duration might have already counted down, e.g. from 30 minutes to
-        // 29 minutes and 59 seconds, so that 29 minutes are displayed
-        int mmTbrDurationInMinutes = mmTbrDuration.getHour() * 60 + mmTbrDuration.getMinute();
-        if (mmTbrPercentage != percentage || (mmTbrDurationInMinutes != duration && mmTbrDurationInMinutes + 1 != duration)) {
-            throw new CommandException().message("Setting TBR failed, TBR in MAIN_MENU differs from expected");
         }
+        return new CommandResult().success(false).message("failed with state: "+state+" from: "+lastState);
     }
 
     @Override

app/src/main/java/info/nightscout/androidaps/plugins/PumpCombo/ComboPlugin.java

@@ -91,6 +91,7 @@ public class ComboPlugin implements PluginBase, PumpInterface {
         MainApp.bus().register(this);
         bindRuffyService();
         startAlerter();
+        ruffyScripter = new RuffyScripter();
     }
 
     private void definePumpCapabilities() {
@@ -163,7 +164,10 @@ public class ComboPlugin implements PluginBase, PumpInterface {
                             mgr.notify(id, notificationBuilder.build());
                             lastAlarmTime = now;
                         } else {
+                            // TODO would it be useful to have a 'last error' field in the ui showing the most recent
+                            // failed command? the next command that runs successful with will override this error
                             log.warn("Pump still in error state, but alarm raised recently, so not triggering again: " + localLastCmdResult.message);
+                            refreshDataFromPump("from Error Recovery");
                         }
                     }
                     SystemClock.sleep(5 * 1000);
@@ -172,7 +176,8 @@ public class ComboPlugin implements PluginBase, PumpInterface {
         }, "combo-alerter").start();
     }
 
-    private void bindRuffyService() {
+    private boolean bindRuffyService() {
+
         Context context = MainApp.instance().getApplicationContext();
         boolean boundSucceeded = false;
 
@@ -185,6 +190,7 @@ public class ComboPlugin implements PluginBase, PumpInterface {
                             // full path to the driver
                             // in the logs this service is mentioned as (note the slash)
                             // "org.monkey.d.ruffy.ruffy/.driver.Ruffy"
+                            //org.monkey.d.ruffy.ruffy is the base package identifier and /.driver.Ruffy the service within the package
                             "org.monkey.d.ruffy.ruffy.driver.Ruffy"
                     ));
             context.startService(intent);
@@ -193,16 +199,22 @@ public class ComboPlugin implements PluginBase, PumpInterface {
 
                 @Override
                 public void onServiceConnected(ComponentName name, IBinder service) {
-                    ruffyScripter = new RuffyScripter(IRuffyService.Stub.asInterface(service));
+                    keepUnbound=false;
-                    ruffyScripter.start();
+                    ruffyScripter.start(IRuffyService.Stub.asInterface(service));
                     log.debug("ruffy serivce connected");
                 }
 
                 @Override
                 public void onServiceDisconnected(ComponentName name) {
                     ruffyScripter.stop();
-                    ruffyScripter = null;
                     log.debug("ruffy service disconnected");
+                    if(!keepUnbound) {
+                        try {
+                            Thread.sleep(250);
+                        } catch (Exception e) {
+                        }
+                        bindRuffyService();
+                    }
                 }
             };
             boundSucceeded = context.bindService(intent, mRuffyServiceConnection, Context.BIND_AUTO_CREATE);
@@ -213,9 +225,13 @@ public class ComboPlugin implements PluginBase, PumpInterface {
         if (!boundSucceeded) {
             statusSummary = "No connection to ruffy. Pump control not available.";
         }
+        return true;
     }
 
+    private boolean keepUnbound = false;
     private void unbindRuffyService() {
+        keepUnbound = true;
+        ruffyScripter.unbind();
         MainApp.instance().getApplicationContext().unbindService(mRuffyServiceConnection);
     }
 
@@ -414,6 +430,7 @@ public class ComboPlugin implements PluginBase, PumpInterface {
         MainApp.bus().post(new EventComboPumpUpdateGUI());
 
         CommandResult commandResult = ruffyScripter.runCommand(command);
+        // TODO extract this into a recovery method and check the logic of restarting and rebinding ruffy
         if (!commandResult.success && commandResult.exception != null) {
             log.error("CommandResult has exception, rebinding ruffy service", commandResult.exception);
 
@@ -421,6 +438,12 @@ public class ComboPlugin implements PluginBase, PumpInterface {
             try {
                 unbindRuffyService();
                 SystemClock.sleep(5000);
+            } catch (Exception e) {
+                /*String msg = "No connection to ruffy. Pump control not available.";
+                statusSummary = msg;
+                return new CommandResult().message(msg);*/
+            }
+            try {
                 bindRuffyService();
                 SystemClock.sleep(5000);
             } catch (Exception e) {
@@ -533,7 +556,7 @@ public class ComboPlugin implements PluginBase, PumpInterface {
     }
 
     @Override
-    public PumpEnactResult cancelTempBasal() {
+    public PumpEnactResult cancelTempBasal(boolean userRequested) {
         log.debug("cancelTempBasal called");
 
         CommandResult commandResult = null;
@@ -543,6 +566,7 @@ public class ComboPlugin implements PluginBase, PumpInterface {
         final TemporaryBasal activeTemp = MainApp.getConfigBuilder().getTempBasalFromHistory(System.currentTimeMillis());
 
         if (activeTemp == null || userRequested) {
+            /* v1 compatibility to sync DB to pump if they diverged (activeTemp == null) */
             log.debug("cancelTempBasal: hard-cancelling TBR since user requested");
             commandResult = runCommand(new CancelTbrCommand());
             if (commandResult.enacted) {
@@ -578,14 +602,14 @@ public class ComboPlugin implements PluginBase, PumpInterface {
 
         if (tempBasal != null) {
             ConfigBuilderPlugin treatmentsInterface = MainApp.getConfigBuilder();
-            treatmentsInterface.addToHistoryTempBasal(tempStop);
+            treatmentsInterface.addToHistoryTempBasal(tempBasal);
         }
 
-        PumpEnactResult pumpEnactResult = new PumpEnactResult();
+        if (commandResult != null) {
-        pumpEnactResult.success = commandResult.success;
+            pumpEnactResult.success = commandResult.success;
-        pumpEnactResult.enacted = commandResult.enacted;
+            pumpEnactResult.enacted = commandResult.enacted;
-        pumpEnactResult.comment = commandResult.message;
+            pumpEnactResult.comment = commandResult.message;
-        pumpEnactResult.isTempCancel = true;
+        }
         return pumpEnactResult;
     }
 

app/src/main/java/org/monkey/d/ruffy/ruffy/driver/display/Menu.java

@@ -35,30 +35,32 @@ public class Menu implements Parcelable{
                 String clas = in.readString();
                 String value = in.readString();
 
-                MenuAttribute a = MenuAttribute.valueOf(attr);
+                if(attr!=null && clas!=null && value!=null) {
-                Object o = null;
+                    MenuAttribute a = MenuAttribute.valueOf(attr);
-                if (Integer.class.toString().equals(clas)) {
+                    Object o = null;
-                    o = new Integer(value);
+                    if (Integer.class.toString().equals(clas)) {
-                } else if (Double.class.toString().equals(clas)) {
+                        o = new Integer(value);
-                    o = new Double(value);
+                    } else if (Double.class.toString().equals(clas)) {
-                } else if (Boolean.class.toString().equals(clas)) {
+                        o = new Double(value);
-                    o = new Boolean(value);
+                    } else if (Boolean.class.toString().equals(clas)) {
-                } else if (MenuDate.class.toString().equals(clas)) {
+                        o = new Boolean(value);
-                    o = new MenuDate(value);
+                    } else if (MenuDate.class.toString().equals(clas)) {
-                } else if (MenuTime.class.toString().equals(clas)) {
+                        o = new MenuDate(value);
-                    o = new MenuTime(value);
+                    } else if (MenuTime.class.toString().equals(clas)) {
-                } else if (MenuBlink.class.toString().equals(clas)) {
+                        o = new MenuTime(value);
-                    o = new MenuBlink();
+                    } else if (MenuBlink.class.toString().equals(clas)) {
-                } else if (BolusType.class.toString().equals(clas)) {
+                        o = new MenuBlink();
-                    o = BolusType.valueOf(value);
+                    } else if (BolusType.class.toString().equals(clas)) {
-                } else if (String.class.toString().equals(clas)) {
+                        o = BolusType.valueOf(value);
-                    o = new String(value);
+                    } else if (String.class.toString().equals(clas)) {
-                }
+                        o = new String(value);
+                    }
 
-                if (o != null) {
+                    if (o != null) {
-                    attributes.put(a, o);
+                        attributes.put(a, o);
-                } else {
+                    } else {
-                    Log.e("MenuIn", "failed to parse: " + attr + " / " + clas + " / " + value);
+                        Log.e("MenuIn", "failed to parse: " + attr + " / " + clas + " / " + value);
+                    }
                 }
             }catch(Exception e)
             {
@@ -120,4 +122,12 @@ public class Menu implements Parcelable{
                     return new Menu[size];
                 }
             };
+
+    @Override
+    public String toString() {
+        String to = "Menu: "+getType()+" atr:";
+        for(MenuAttribute atr : attributes())
+            to+=atr.toString()+"="+getAttribute(atr)+";";
+        return to;
+    }
 }

app/src/main/java/org/monkey/d/ruffy/ruffy/driver/display/MenuType.java

@@ -5,38 +5,47 @@ package org.monkey.d.ruffy.ruffy.driver.display;
  */
 
 public enum MenuType {
-    MAIN_MENU,
+    MAIN_MENU(true),
-    STOP_MENU,
+    STOP_MENU(true),
-    BOLUS_MENU,
+    BOLUS_MENU(true),
-    BOLUS_ENTER,
+    BOLUS_ENTER(false),
-    EXTENDED_BOLUS_MENU,
+    EXTENDED_BOLUS_MENU(true),
-    BOLUS_DURATION,
+    BOLUS_DURATION(false),
-    MULTIWAVE_BOLUS_MENU,
+    MULTIWAVE_BOLUS_MENU(true),
-    IMMEDIATE_BOLUS,
+    IMMEDIATE_BOLUS(false),
-    TBR_MENU,
+    TBR_MENU(true),
-    MY_DATA_MENU,
+    MY_DATA_MENU(true),
-    BASAL_MENU,
+    BASAL_MENU(true),
-    BASAL_1_MENU,
+    BASAL_1_MENU(true),
-    BASAL_2_MENU,
+    BASAL_2_MENU(true),
-    BASAL_3_MENU,
+    BASAL_3_MENU(true),
-    BASAL_4_MENU,
+    BASAL_4_MENU(true),
-    BASAL_5_MENU,
+    BASAL_5_MENU(true),
-    DATE_AND_TIME_MENU,
+    DATE_AND_TIME_MENU(true),
-    ALARM_MENU,
+    ALARM_MENU(true),
-    MENU_SETTINGS_MENU,
+    MENU_SETTINGS_MENU(true),
-    BLUETOOTH_MENU,
+    BLUETOOTH_MENU(true),
-    THERAPY_MENU,
+    THERAPY_MENU(true),
-    PUMP_MENU,
+    PUMP_MENU(true),
-    QUICK_INFO,
+    QUICK_INFO(false),
-    BOLUS_DATA,
+    BOLUS_DATA(false),
-    DAILY_DATA,
+    DAILY_DATA(false),
-    TBR_DATA,
+    TBR_DATA(false),
-    ERROR_DATA,
+    ERROR_DATA(false),
-    TBR_SET,
+    TBR_SET(false),
-    TBR_DURATION,
+    TBR_DURATION(false),
-    STOP,
+    STOP(false),
-    START_MENU,
+    START_MENU(false),
-    BASAL_TOTAL,
+    BASAL_TOTAL(false),
-    BASAL_SET,
+    BASAL_SET(false),
-    WARNING_OR_ERROR,
+    WARNING_OR_ERROR(false),;
+
+    private boolean maintype = false;
+    MenuType(boolean b) {
+        maintype=b;
+    }
+
+    public boolean isMaintype() {
+        return maintype;
+    }
 }