diff --git a/app/build.gradle b/app/build.gradle index 24f609f8a9..dd040d8e39 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-dev" 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..f329a71df3 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,48 @@ 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 (ruffyService != null) { + try { + ruffyService.removeHandler(mHandler); + } catch (Exception e) { + // ignore + } + } + 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; + newService.addHandler(mHandler); + } + } 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 +98,7 @@ public class RuffyScripter { return started; } + private boolean canDisconnect = false; private Thread idleDisconnectMonitorThread = new Thread(new Runnable() { @Override public void run() { @@ -91,20 +112,22 @@ 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); + } else { + canDisconnect = false; } - } catch (DeadObjectException doe) { + } 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 +151,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 +178,19 @@ 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()); + log.debug("rtDisplayHandleMenu: " + menu); currentMenu = menu; menuLastUpdated = System.currentTimeMillis(); + synchronized (screenlock) { + screenlock.notifyAll(); + } + + // TODO v2 switch to using IRuffyService.isConnected, rather than guessing connectivity state + // passed on screen updates connected = true; // note that a WARNING_OR_ERROR menu can be a valid temporary state (cancelling TBR) @@ -167,16 +201,42 @@ 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) { + // ignore + } + this.ruffyService = null; + } + private static class Returnable { CommandResult cmdResult; } @@ -304,7 +364,9 @@ public class RuffyScripter { } } - /** If there's an issue, this times out eventually and throws a CommandException */ + /** + * If there's an issue, this times out eventually and throws a CommandException + */ private void ensureConnected() { try { boolean menuUpdateRecentlyReceived = currentMenu != null && menuLastUpdated + 1000 > System.currentTimeMillis(); @@ -324,7 +386,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 +400,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,47 +410,103 @@ 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 waitForScreenUpdate(long timeout) { + synchronized (screenlock) { + try { + screenlock.wait(timeout); + } catch (Exception e) { + return false; + } + } + return true; + } + + public boolean goToMainTypeScreen(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) { + throw new CommandException().message("Warning/errors raised by pump, please check pump"); + // since warnings and errors can occur at any time, they should be dealt with in + // a more general way, see the handleMenuUpdate callback above + //FIXME bad thing to do :D + // yup, commenting this out since I don't want an occlusionn alert to hidden by this :-) + //pressCheckKey(); + } else if (currentMenu != null && !currentMenu.getType().isMaintype()) { + pressBackKey(); + } else + pressMenuKey(); + waitForScreenUpdate(250); + } + return currentMenu != null && currentMenu.getType() == screen; + } + + public boolean enterMenu(MenuType startType, MenuType targetType, byte key, long timeout) { + if (currentMenu.getType() == targetType) + return true; + 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()) { + waitForScreenUpdate(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, // so we can use a custom timeout and give a better error message in case of failure + /** * Wait until the menu update is in */ public void waitForMenuUpdate() { - waitForMenuUpdate(60); + waitForMenuUpdate(60); } public void waitForMenuUpdate(long timeoutInSeconds) { @@ -401,12 +520,21 @@ 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..09958f6bf1 --- /dev/null +++ b/app/src/main/java/de/jotomo/ruffyscripter/commands/GetBasalCommand.java @@ -0,0 +1,124 @@ +package de.jotomo.ruffyscripter.commands; + +import android.util.Log; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import de.jotomo.ruffyscripter.PumpState; +import de.jotomo.ruffyscripter.RuffyScripter; + +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; + } + +// 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.goToMainTypeScreen(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.waitForScreenUpdate(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) { + try { + Map rate = new HashMap<>(); + + for(int i = 0; i < 24;i++) + { + Log.v("BASAL_RATE","BASAL_RATE from "+String.format("%02d",i)+":00 = "+rate.get(i)); + } + } catch (Exception e) { + log.error("failed to get basal",e); + return new CommandResult().success(false).message("failed to get basal: "+e.getMessage()); + } + return new CommandResult().success(true).enacted(true).message("Basal Rate was read"); + } + + @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 4ffd154acf..137a1a8196 100644 --- a/app/src/main/java/de/jotomo/ruffyscripter/commands/SetTbrCommand.java +++ b/app/src/main/java/de/jotomo/ruffyscripter/commands/SetTbrCommand.java @@ -15,6 +15,12 @@ import java.util.Locale; import de.jotomo.ruffyscripter.PumpState; import de.jotomo.ruffyscripter.RuffyScripter; +import static org.monkey.d.ruffy.ruffy.driver.display.MenuType.MAIN_MENU; +import static org.monkey.d.ruffy.ruffy.driver.display.MenuType.TBR_DURATION; +import static org.monkey.d.ruffy.ruffy.driver.display.MenuType.TBR_MENU; +import static org.monkey.d.ruffy.ruffy.driver.display.MenuType.TBR_SET; +import static org.monkey.d.ruffy.ruffy.driver.display.MenuType.WARNING_OR_ERROR; + public class SetTbrCommand implements Command { private static final Logger log = LoggerFactory.getLogger(SetTbrCommand.class); @@ -56,239 +62,205 @@ public class SetTbrCommand implements Command { @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); + log.debug("1. going from " + scripter.currentMenu + " to TBR_MENU"); + int retries = 5; + while (!scripter.goToMainTypeScreen(TBR_MENU, 3000)) { + retries--; + if (retries == 0) + throw new CommandException().message("not able to find TBR_MENU: stuck in " + scripter.currentMenu); + SystemClock.sleep(500); + if (scripter.currentMenu.getType() == TBR_MENU) + break; } - 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."); + if (scripter.currentMenu.getType() != TBR_MENU) + throw new CommandException().message("not able to find TBR_MENU: stuck in " + scripter.currentMenu); - // 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 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); - } - 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); - } - } - - 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."); + log.debug("2. entering " + scripter.currentMenu); + retries = 5; + while (!scripter.enterMenu(TBR_MENU, MenuType.TBR_SET, RuffyScripter.Key.CHECK, 2000)) { + retries--; + if (retries == 0) + throw new CommandException().message("not able to find TBR_SET: stuck in " + scripter.currentMenu); + SystemClock.sleep(500); + if (scripter.currentMenu.getType() == TBR_SET) + break; + if (scripter.currentMenu.getType() == TBR_DURATION) { + scripter.pressMenuKey(); + scripter.waitForScreenUpdate(1000); } - // 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); - } - } - 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"); - } - } + log.debug("SetTbrCommand: 3. getting/setting basal percentage in " + scripter.currentMenu); + retries = 30; - 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"); + double currentPercentage = -100; + while (currentPercentage != percentage && retries >= 0) { + retries--; + Object percentageObj = scripter.currentMenu.getAttribute(MenuAttribute.BASAL_RATE); + + if (percentageObj != null && (percentageObj instanceof Double)) { + currentPercentage = ((Double) percentageObj).doubleValue(); + + if (currentPercentage != percentage) { + int requestedPercentage = (int) percentage; + int actualPercentage = (int) currentPercentage; + int steps = (requestedPercentage - actualPercentage) / 10; + log.debug("Adjusting basal(" + requestedPercentage + "/" + actualPercentage + ") with " + steps + " steps and " + retries + " retries left"); + scripter.step(steps, (steps < 0 ? RuffyScripter.Key.DOWN : RuffyScripter.Key.UP), 500); + scripter.waitForScreenUpdate(1000); + } + + } else { + currentPercentage = -100; + } + scripter.waitForScreenUpdate(1000); + } + if (currentPercentage < 0 || retries < 0) + throw new CommandException().message("unable to set basal percentage"); + + log.debug("4. checking basal percentage in " + scripter.currentMenu); + scripter.waitForScreenUpdate(1000); + currentPercentage = -1000; + retries = 10; + while (currentPercentage < 0 && retries >= 0) { + retries--; + Object percentageObj = scripter.currentMenu.getAttribute(MenuAttribute.BASAL_RATE); + + if (percentageObj != null && (percentageObj instanceof Double)) { + currentPercentage = ((Double) percentageObj).doubleValue(); + } else { + scripter.waitForScreenUpdate(1000); + } + } + + if (retries < 0 || currentPercentage != percentage) + throw new CommandException().message("Unable to set percentage. Requested: " + percentage + ", value displayed on pump: " + currentPercentage); + + if (currentPercentage != 100) { + log.debug("5. change to TBR_DURATION from " + scripter.currentMenu); + retries = 5; + while (retries >= 0 && !scripter.enterMenu(TBR_SET, MenuType.TBR_DURATION, RuffyScripter.Key.MENU, 2000)) { + retries--; + if (retries == 0) + throw new CommandException().message("not able to find TBR_SET: stuck in " + scripter.currentMenu); + SystemClock.sleep(500); + if (scripter.currentMenu.getType() == TBR_DURATION) + break; + if (scripter.currentMenu.getType() == TBR_SET) { + scripter.pressMenuKey(); + scripter.waitForScreenUpdate(1000); + } + } + + log.debug("6. getting/setting duration in " + scripter.currentMenu); + retries = 30; + + double currentDuration = -100; + while (currentDuration != duration && retries >= 0) { + retries--; + Object durationObj = scripter.currentMenu.getAttribute(MenuAttribute.RUNTIME); + log.debug("Requested time: " + duration + " actual time: " + durationObj); + if (durationObj != null && durationObj instanceof MenuTime) { + MenuTime time = (MenuTime) durationObj; + currentDuration = (time.getHour() * 60) + time.getMinute(); + if (currentDuration != duration) { + int requestedDuration = (int) duration; + int actualDuration = (int) currentDuration; + int steps = (requestedDuration - actualDuration) / 15; + if (currentDuration + (steps * 15) < requestedDuration) + steps++; + else if (currentDuration + (steps * 15) > requestedDuration) + steps--; + log.debug("Adjusting duration(" + requestedDuration + "/" + actualDuration + ") with " + steps + " steps and " + retries + " retries left"); + scripter.step(steps, (steps > 0 ? RuffyScripter.Key.UP : RuffyScripter.Key.DOWN), 500); + scripter.waitForScreenUpdate(1000); + } + } + scripter.waitForScreenUpdate(1000); + } + if (currentDuration < 0 || retries < 0) + throw new CommandException().message("unable to set duration, requested:" + duration + ", displayed on pump: " + currentDuration); + + log.debug("7. checking duration in " + scripter.currentMenu); + scripter.waitForScreenUpdate(1000); + currentDuration = -1000; + retries = 10; + while (currentDuration < 0 && retries >= 0) { + retries--; + Object durationObj = scripter.currentMenu.getAttribute(MenuAttribute.RUNTIME); + + if (durationObj != null && durationObj instanceof MenuTime) { + MenuTime time = (MenuTime) durationObj; + currentDuration = (time.getHour() * 60) + time.getMinute(); + } else + scripter.waitForScreenUpdate(1000); + } + if (retries < 0 || currentDuration != duration) + throw new CommandException().message("wrong duration! Requested: " + duration + ", displayed on pump: " + currentDuration); + } + + log.debug("8. confirming TBR om " + scripter.currentMenu); + retries = 5; + while (retries >= 0 && (scripter.currentMenu.getType() == TBR_DURATION || scripter.currentMenu.getType() == TBR_SET)) { + retries--; + scripter.pressCheckKey(); + scripter.waitForScreenUpdate(1000); + } + if (retries < 0 || scripter.currentMenu.getType() == TBR_DURATION || scripter.currentMenu.getType() == TBR_SET) + throw new CommandException().message("failed setting basal!"); + retries = 10; + boolean cancelledError = true; + if (percentage == 100) + cancelledError = false; + while (retries >= 0 && scripter.currentMenu.getType() != MAIN_MENU) { + // TODO how probable is it, that a totally unrelated error (like occlusion alert) + // is raised at this point, which we'd cancel together with the TBR cancelled alert? + if (percentage == 100 && scripter.currentMenu.getType() == WARNING_OR_ERROR) { + scripter.pressCheckKey(); + retries++; + cancelledError = true; + scripter.waitForScreenUpdate(1000); + } else { + retries--; + if (scripter.currentMenu.getType() == MAIN_MENU && cancelledError) + break; + } + } + + log.debug("9. verifying the main menu display the TBR we just set/cancelled"); + if (retries < 0 || scripter.currentMenu.getType() != MAIN_MENU) + throw new CommandException().message("failed going to main!"); + + Object percentageObj = scripter.currentMenu.getAttribute(MenuAttribute.TBR); + Object durationObj = scripter.currentMenu.getAttribute(MenuAttribute.RUNTIME); + + if (percentage == 100) { + if (percentageObj != null || durationObj != null) + throw new CommandException().message("TBR cancelled, but main menu shows a running TBR"); + + return new CommandResult().success(true).enacted(true).message("TBR was cancelled"); + } + + if (percentageObj == null || !(percentageObj instanceof Double)) + throw new CommandException().message("not percentage"); + + if (((double) percentageObj) != percentage) + throw new CommandException().message("wrong percentage set!"); + + if (durationObj == null || !(durationObj instanceof MenuTime)) + throw new CommandException().message("not time"); + + MenuTime t = (MenuTime) durationObj; + if (t.getMinute() + (60 * t.getHour()) > duration || t.getMinute() + (60 * t.getHour()) < duration - 5) + throw new CommandException().message("wrong time set!"); + + + return new CommandResult().success(true).enacted(true).message( + String.format(Locale.US, "TBR set to %d%% for %d min", percentage, duration)); + } catch (Exception e) { + log.error("got exception: ", e); + return new CommandResult().success(false).message("failed to wait: " + e.getMessage()); } } 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 02dfd805ee..696c87ba2d 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,19 @@ 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) { + SystemClock.sleep(250); + bindRuffyService(); + } } }; boundSucceeded = context.bindService(intent, mRuffyServiceConnection, Context.BIND_AUTO_CREATE); @@ -213,9 +222,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 +427,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 +435,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) { @@ -502,6 +522,7 @@ public class ComboPlugin implements PluginBase, PumpInterface { } CommandResult commandResult = runCommand(new SetTbrCommand(adjustedPercent, durationInMinutes)); + if (commandResult.enacted) { TemporaryBasal tempStart = new TemporaryBasal(commandResult.completionTime); // TODO commandResult.state.tbrRemainingDuration might already display 29 if 30 was set, since 29:59 is shown as 29 ... @@ -542,6 +563,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) { 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; + } }