diff --git a/app/build.gradle b/app/build.gradle index 24f609f8a9..c8e5636b6b 100644 --- a/app/build.gradle +++ b/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() } diff --git a/app/src/androidTest/java/ruffyscripter/RuffyScripterInstrumentedTest.java b/app/src/androidTest/java/ruffyscripter/RuffyScripterInstrumentedTest.java index 4374de8bc0..afc17ff868 100644 --- a/app/src/androidTest/java/ruffyscripter/RuffyScripterInstrumentedTest.java +++ b/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"); } diff --git a/app/src/main/aidl/org/monkey/d/ruffy/ruffy/driver/IRTHandler.aidl b/app/src/main/aidl/org/monkey/d/ruffy/ruffy/driver/IRTHandler.aidl index 996b10b666..b6a07226b8 100644 --- a/app/src/main/aidl/org/monkey/d/ruffy/ruffy/driver/IRTHandler.aidl +++ b/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 rtDisplayHandleNoMenu(); + void rtDisplayHandleMenu(in Menu menu, in int sequence); + void rtDisplayHandleNoMenu(in int sequence); + + void keySent(in int sequence); + + String getServiceIdentifier(); } diff --git a/app/src/main/aidl/org/monkey/d/ruffy/ruffy/driver/IRuffyService.aidl b/app/src/main/aidl/org/monkey/d/ruffy/ruffy/driver/IRuffyService.aidl index ded119c7b4..f4879445b7 100644 --- a/app/src/main/aidl/org/monkey/d/ruffy/ruffy/driver/IRuffyService.aidl +++ b/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*/ diff --git a/app/src/main/java/de/jotomo/ruffyscripter/RuffyScripter.java b/app/src/main/java/de/jotomo/ruffyscripter/RuffyScripter.java index 5a29c46985..761d8aa312 100644 --- a/app/src/main/java/de/jotomo/ruffyscripter/RuffyScripter.java +++ b/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) { - this.ruffyService = ruffyService; + private final Object keylock = new Object(); + private int keynotwait = 0; + + private final Object screenlock = new Object(); + + public RuffyScripter() { + } - public void start() { + public void start(IRuffyService newService) { try { - ruffyService.addHandler(mHandler); - idleDisconnectMonitorThread.start(); - started = true; - } catch (RemoteException e) { + if(newService!=null) { + this.ruffyService = newService; + // TODO this'll be done better in v2 via ConnectionManager + 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"; - } catch (RemoteException e) { + //unrecoverableError = "Ruffy service went away"; 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 { - static byte NO_KEY = (byte) 0x00; - static byte MENU = (byte) 0x03; - static byte CHECK = (byte) 0x0C; - static byte UP = (byte) 0x30; - static byte DOWN = (byte) 0xC0; + public static class Key { + public static byte NO_KEY = (byte) 0x00; + public static byte MENU = (byte) 0x03; + public static byte CHECK = (byte) 0x0C; + public static byte UP = (byte) 0x30; + 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"); } } diff --git a/app/src/main/java/de/jotomo/ruffyscripter/commands/GetBasalCommand.java b/app/src/main/java/de/jotomo/ruffyscripter/commands/GetBasalCommand.java new file mode 100644 index 0000000000..8305e72031 --- /dev/null +++ b/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 validateArguments() { + List 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 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{}"; + } +} diff --git a/app/src/main/java/de/jotomo/ruffyscripter/commands/SetTbrCommand.java b/app/src/main/java/de/jotomo/ruffyscripter/commands/SetTbrCommand.java index fe4b46c5f5..670d51411a 100644 --- a/app/src/main/java/de/jotomo/ruffyscripter/commands/SetTbrCommand.java +++ b/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 - public CommandResult execute(RuffyScripter scripter, PumpState initialPumpState) { - try { - enterTbrMenu(scripter); - inputTbrPercentage(scripter); - verifyDisplayedTbrPercentage(scripter); - - if (percentage == 100) { - cancelTbrAndConfirmCancellationWarning(scripter); - } else { - // switch to TBR_DURATION menu by pressing menu key - scripter.verifyMenuIsDisplayed(MenuType.TBR_SET); - scripter.pressMenuKey(); - scripter.waitForMenuUpdate(); - scripter.verifyMenuIsDisplayed(MenuType.TBR_DURATION); - - inputTbrDuration(scripter); - verifyDisplayedTbrDuration(scripter); - - // confirm TBR - scripter.pressCheckKey(); - scripter.waitForMenuToBeLeft(MenuType.TBR_DURATION); + enum State { + BEFORE, + MAIN, + TBR, + SET_TBR, + TIME, + SET_TIME, + SET, + AFTER, + ERROR + }; + 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(); + } } - - 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(); + tick(); } + }; + 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) { - // TODO v2 add timeout? Currently the command execution timeout would trigger if exceeded - Object percentageObj = scripter.currentMenu.getAttribute(MenuAttribute.BASAL_RATE); - // 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; + try { + synchronized (this) { + this.wait(); } - 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) { - scripter.verifyMenuIsDisplayed(MenuType.MAIN_MENU); - 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(true).enacted(true).message( + String.format(Locale.US, "TBR set to %d%% for %d min", percentage, duration)); } + return new CommandResult().success(false).message("failed with state: "+state+" from: "+lastState); } @Override diff --git a/app/src/main/java/info/nightscout/androidaps/plugins/PumpCombo/ComboPlugin.java b/app/src/main/java/info/nightscout/androidaps/plugins/PumpCombo/ComboPlugin.java index 85aea8011d..b276c23594 100644 --- a/app/src/main/java/info/nightscout/androidaps/plugins/PumpCombo/ComboPlugin.java +++ b/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)); - ruffyScripter.start(); + keepUnbound=false; + 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(); - pumpEnactResult.success = commandResult.success; - pumpEnactResult.enacted = commandResult.enacted; - pumpEnactResult.comment = commandResult.message; - pumpEnactResult.isTempCancel = true; + if (commandResult != null) { + pumpEnactResult.success = commandResult.success; + pumpEnactResult.enacted = commandResult.enacted; + pumpEnactResult.comment = commandResult.message; + } return pumpEnactResult; } diff --git a/app/src/main/java/org/monkey/d/ruffy/ruffy/driver/display/Menu.java b/app/src/main/java/org/monkey/d/ruffy/ruffy/driver/display/Menu.java index 20e74c7805..24a57b7d15 100644 --- a/app/src/main/java/org/monkey/d/ruffy/ruffy/driver/display/Menu.java +++ b/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); - Object o = null; - if (Integer.class.toString().equals(clas)) { - o = new Integer(value); - } else if (Double.class.toString().equals(clas)) { - o = new Double(value); - } else if (Boolean.class.toString().equals(clas)) { - o = new Boolean(value); - } else if (MenuDate.class.toString().equals(clas)) { - o = new MenuDate(value); - } else if (MenuTime.class.toString().equals(clas)) { - o = new MenuTime(value); - } else if (MenuBlink.class.toString().equals(clas)) { - o = new MenuBlink(); - } else if (BolusType.class.toString().equals(clas)) { - o = BolusType.valueOf(value); - } else if (String.class.toString().equals(clas)) { - o = new String(value); - } + if(attr!=null && clas!=null && value!=null) { + MenuAttribute a = MenuAttribute.valueOf(attr); + Object o = null; + if (Integer.class.toString().equals(clas)) { + o = new Integer(value); + } else if (Double.class.toString().equals(clas)) { + o = new Double(value); + } else if (Boolean.class.toString().equals(clas)) { + o = new Boolean(value); + } else if (MenuDate.class.toString().equals(clas)) { + o = new MenuDate(value); + } else if (MenuTime.class.toString().equals(clas)) { + o = new MenuTime(value); + } else if (MenuBlink.class.toString().equals(clas)) { + o = new MenuBlink(); + } else if (BolusType.class.toString().equals(clas)) { + o = BolusType.valueOf(value); + } else if (String.class.toString().equals(clas)) { + o = new String(value); + } - if (o != null) { - attributes.put(a, o); - } else { - Log.e("MenuIn", "failed to parse: " + attr + " / " + clas + " / " + value); + if (o != null) { + attributes.put(a, o); + } else { + 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; + } } diff --git a/app/src/main/java/org/monkey/d/ruffy/ruffy/driver/display/MenuType.java b/app/src/main/java/org/monkey/d/ruffy/ruffy/driver/display/MenuType.java index 4d00ea9155..2fb7a53f67 100644 --- a/app/src/main/java/org/monkey/d/ruffy/ruffy/driver/display/MenuType.java +++ b/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, - STOP_MENU, - BOLUS_MENU, - BOLUS_ENTER, - EXTENDED_BOLUS_MENU, - BOLUS_DURATION, - MULTIWAVE_BOLUS_MENU, - IMMEDIATE_BOLUS, - TBR_MENU, - MY_DATA_MENU, - BASAL_MENU, - BASAL_1_MENU, - BASAL_2_MENU, - BASAL_3_MENU, - BASAL_4_MENU, - BASAL_5_MENU, - DATE_AND_TIME_MENU, - ALARM_MENU, - MENU_SETTINGS_MENU, - BLUETOOTH_MENU, - THERAPY_MENU, - PUMP_MENU, - QUICK_INFO, - BOLUS_DATA, - DAILY_DATA, - TBR_DATA, - ERROR_DATA, - TBR_SET, - TBR_DURATION, - STOP, - START_MENU, - BASAL_TOTAL, - BASAL_SET, - WARNING_OR_ERROR, + MAIN_MENU(true), + STOP_MENU(true), + BOLUS_MENU(true), + BOLUS_ENTER(false), + EXTENDED_BOLUS_MENU(true), + BOLUS_DURATION(false), + MULTIWAVE_BOLUS_MENU(true), + IMMEDIATE_BOLUS(false), + TBR_MENU(true), + MY_DATA_MENU(true), + BASAL_MENU(true), + BASAL_1_MENU(true), + BASAL_2_MENU(true), + BASAL_3_MENU(true), + BASAL_4_MENU(true), + BASAL_5_MENU(true), + DATE_AND_TIME_MENU(true), + ALARM_MENU(true), + MENU_SETTINGS_MENU(true), + BLUETOOTH_MENU(true), + THERAPY_MENU(true), + PUMP_MENU(true), + QUICK_INFO(false), + BOLUS_DATA(false), + DAILY_DATA(false), + TBR_DATA(false), + ERROR_DATA(false), + TBR_SET(false), + TBR_DURATION(false), + STOP(false), + START_MENU(false), + BASAL_TOTAL(false), + BASAL_SET(false), + WARNING_OR_ERROR(false),; + + private boolean maintype = false; + MenuType(boolean b) { + maintype=b; + } + + public boolean isMaintype() { + return maintype; + } }