Return to form entry after session expiration via SSD

app/src/org/commcare/activities/FormEntryActivity.java

@@ -219,8 +219,11 @@ public boolean onMenuItemSelected(int featureId, MenuItem item) {
     public void formSaveCallback() {
         // note that we have started saving the form
         savingFormOnKeySessionExpiration = true;
-        // start saving form, which will call the key session logout completion
-        // function when it finishes.
+
+        // Set flag that will allow us to restore this form when we log back in
+        CommCareApplication.instance().getCurrentSessionWrapper().setCurrentStateAsInterrupted();
+
+        // Start saving form; will trigger expireUserSession() on completion
         saveIncompleteFormToDisk();
     }
 

app/src/org/commcare/activities/HomeScreenBaseActivity.java

@@ -132,6 +132,10 @@ public abstract class HomeScreenBaseActivity<T> extends SyncCapableCommCareActiv
     private boolean wasExternal = false;
     private static final String WAS_EXTERNAL_KEY = "was_external";
 
+    // Indicates if 1 of the checks we performed in onCreate resulted in redirecting to a
+    // different activity or starting a UI-blocking task
+    private boolean redirectedInOnCreate = false;
+
     @Override
     public void onCreateSessionSafe(Bundle savedInstanceState) {
         super.onCreateSessionSafe(savedInstanceState);
@@ -171,59 +175,113 @@ private void processFromShortcutLaunch() {
     private void processFromLoginLaunch() {
         if (getIntent().getBooleanExtra(DispatchActivity.START_FROM_LOGIN, false) &&
                 !loginExtraWasConsumed) {
-
             getIntent().removeExtra(DispatchActivity.START_FROM_LOGIN);
             loginExtraWasConsumed = true;
-
-            CommCareSession session = CommCareApplication.instance().getCurrentSession();
-            if (session.getCommand() != null) {
-                // restore the session state if there is a command.
-                // For debugging and occurs when a serialized
-                // session is stored upon login
-                isRestoringSession = true;
-                sessionNavigator.startNextSessionStep();
-                return;
+            try {
+                redirectedInOnCreate = doLoginLaunchChecksInOrder();
+            } finally {
+                // make sure this happens no matter what
+                clearOneTimeLoginActionFlags();
             }
+        }
+    }
+
+    /**
+     * The order of operations in this method is very deliberate, and the logic for it is as
+     * follows:
+     * - If we're in demo mode, then we don't want to do any of the other checks because they're
+     * not relevant
+     * - Form and session restorations need to happen before we try to sync, because once we sync
+     * it could invalidate those states
+     * - Restoring a form that was interrupted by session expiration comes before restoring a saved
+     * session because it is of higher importance
+     * - Check for a post-update sync before doing a standard background form-send, since a sync
+     * action will include a form-send action
+     * - Once we're past that point, starting a background form-send process is safe, and we can
+     * safely do checkForPinLaunchConditions() at the same time
+     */
+    private boolean doLoginLaunchChecksInOrder() {
+        if (isDemoUser()) {
+            showDemoModeWarning();
+            return false;
+        }
+
+        if (tryRestoringFormFromSessionExpiration()) {
+            return true;
+        }
+
+        if (tryRestoringSession()) {
+            return true;
+        }
 
+        if (CommCareApplication.instance().isPostUpdateSyncNeeded()) {
+            HiddenPreferences.setPostUpdateSyncNeeded(false);
+            triggerSync(false);
+            return true;
+        }
+
+        if (!CommCareApplication.instance().isSyncPending(false)) {
             // Trigger off a regular unsent task processor, unless we're about to sync (which will
             // then handle this in a blocking fashion)
-            if (!CommCareApplication.instance().isSyncPending(false)) {
-                checkAndStartUnsentFormsTask(false, false);
-            }
+            checkAndStartUnsentFormsTask(false, false);
+        }
 
-            if (isDemoUser()) {
-                showDemoModeWarning();
-                return;
-            }
-            if (checkForPinLaunchConditions()) {
-                return;
-            }
+        checkForPinLaunchConditions();
+
+        return false;
+    }
+
+    /**
+     * Regardless of what action(s) we ended up executing in doLoginLaunchChecksInOrder(), we
+     * don't want to end up trying the actions associated with these flags again at a later point.
+     * They either need to happen the first time on login, or not at all.
+     */
+    private void clearOneTimeLoginActionFlags() {
+        HiddenPreferences.setPostUpdateSyncNeeded(false);
+        HiddenPreferences.clearInterruptedSSD();
+    }
+
+    private boolean tryRestoringFormFromSessionExpiration() {
+        SessionStateDescriptor existing = AndroidSessionWrapper.getFormStateForInterruptedUserSession();
+        if (existing != null) {
+            AndroidSessionWrapper state = CommCareApplication.instance().getCurrentSessionWrapper();
+            state.loadFromStateDescription(existing);
+            formEntry(CommCareApplication.instance().getCommCarePlatform()
+                    .getFormContentUri(state.getSession().getForm()), state.getFormRecord());
+            return true;
         }
+        return false;
+    }
+
+    private boolean tryRestoringSession() {
+        CommCareSession session = CommCareApplication.instance().getCurrentSession();
+        if (session.getCommand() != null) {
+            // Restore the session state if there is a command. This is for debugging and
+            // occurs when a serialized session was stored by a previous user session
+            isRestoringSession = true;
+            sessionNavigator.startNextSessionStep();
+            return true;
+        }
+        return false;
     }
 
     /**
      * See if we should launch either the pin choice dialog, or the create pin activity directly
-     *
-     * @return true if we launched a dialog
      */
-    private boolean checkForPinLaunchConditions() {
+    private void checkForPinLaunchConditions() {
         LoginMode loginMode = (LoginMode)getIntent().getSerializableExtra(LoginActivity.LOGIN_MODE);
         if (loginMode == LoginMode.PRIMED) {
             launchPinCreateScreen(loginMode);
-            return true;
-        }
-        if (loginMode == LoginMode.PASSWORD && DeveloperPreferences.shouldOfferPinForLogin()) {
+        } else if (loginMode == LoginMode.PASSWORD && DeveloperPreferences.shouldOfferPinForLogin()) {
             boolean userManuallyEnteredPasswordMode = getIntent()
                     .getBooleanExtra(LoginActivity.MANUAL_SWITCH_TO_PW_MODE, false);
             boolean alreadyDismissedPinCreation =
                     CommCareApplication.instance().getCurrentApp().getAppPreferences()
                             .getBoolean(HiddenPreferences.HAS_DISMISSED_PIN_CREATION, false);
             if (!alreadyDismissedPinCreation || userManuallyEnteredPasswordMode) {
                 showPinChoiceDialog(loginMode);
-                return true;
             }
         }
-        return false;
     }
 
     private void showPinChoiceDialog(final LoginMode loginMode) {
@@ -403,22 +461,31 @@ int record = intent.getIntExtra("FORMRECORDS", -1);
                     }
                     break;
                 case GET_COMMAND:
-                    boolean fetchNext = processReturnFromGetCommand(resultCode, intent);
-                    if (!fetchNext) {
+                    boolean continueWithSessionNav =
+                            processReturnFromGetCommand(resultCode, intent);
+                    if (!continueWithSessionNav) {
                         return;
                     }
                     break;
                 case GET_CASE:
-                    fetchNext = processReturnFromGetCase(resultCode, intent);
-                    if (!fetchNext) {
+                    continueWithSessionNav = processReturnFromGetCase(resultCode, intent);
+                    if (!continueWithSessionNav) {
                         return;
                     }
                     break;
                 case MODEL_RESULT:
-                    fetchNext = processReturnFromFormEntry(resultCode, intent);
-                    if (!fetchNext) {
+                    continueWithSessionNav = processReturnFromFormEntry(resultCode, intent);
+                    if (!continueWithSessionNav) {
                         return;
                     }
+                    if (!CommCareApplication.instance().getSession().appHealthChecksCompleted()) {
+                        // If we haven't done these checks yet in this user session, try to
+                        if (checkForPendingAppHealthActions()) {
+                            // If we kick one off, abandon the session navigation that we were
+                            // going to proceed with, because it may be invalid now
+                            return;
+                        }
+                    }
                     break;
                 case AUTHENTICATION_FOR_PIN:
                     if (resultCode == RESULT_OK) {
@@ -1024,19 +1091,18 @@ private void triggerSync(boolean triggeredByAutoSyncPending) {
 
     @Override
     public void onResumeSessionSafe() {
-        if (!sessionNavigationProceedingAfterOnResume) {
+        if (!redirectedInOnCreate && !sessionNavigationProceedingAfterOnResume) {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
                 refreshActionBar();
             }
             attemptDispatchHomeScreen();
         }
 
+        // reset these
+        redirectedInOnCreate = false;
         sessionNavigationProceedingAfterOnResume = false;
     }
 
-    /**
-     * Decides if we should actually be on the home screen, or else should redirect elsewhere
-     */
     private void attemptDispatchHomeScreen() {
         try {
             CommCareApplication.instance().getSession();
@@ -1047,19 +1113,29 @@ private void attemptDispatchHomeScreen() {
             return;
         }
 
-        if (CommCareApplication.instance().isPostUpdateSyncNeeded() && !isDemoUser()) {
-            HiddenPreferences.setPostUpdateSyncNeeded(false);
-            triggerSync(false);
-        } else if (CommCareApplication.instance().isSyncPending(false)) {
-            triggerSync(true);
-        } else if (UpdatePromptHelper.promptForUpdateIfNeeded(this)) {
-            return;
-        } else {
+        if (!checkForPendingAppHealthActions()) {
             // Display the home screen!
             refreshUI();
         }
     }
 
+    /**
+     *
+     * @return true if we kicked off any processes
+     */
+    private boolean checkForPendingAppHealthActions() {
+        boolean result = false;
+        if (CommCareApplication.instance().isSyncPending(false)) {
+            triggerSync(true);
+            result = true;
+        } else if (UpdatePromptHelper.promptForUpdateIfNeeded(this)) {
+            result = true;
+        }
+
+        CommCareApplication.instance().getSession().setAppHealthChecksCompleted();
+        return result;
+    }
+
     private void createAskUseOldDialog(final AndroidSessionWrapper state, final SessionStateDescriptor existing) {
         final AndroidCommCarePlatform platform = CommCareApplication.instance().getCommCarePlatform();
         String title = Localization.get("app.workflow.incomplete.continue.title");

app/src/org/commcare/models/AndroidSessionWrapper.java

@@ -7,6 +7,7 @@
 import org.commcare.android.database.user.models.FormRecord;
 import org.commcare.android.database.user.models.SessionStateDescriptor;
 import org.commcare.modern.session.SessionWrapperInterface;
+import org.commcare.preferences.HiddenPreferences;
 import org.commcare.session.CommCareSession;
 import org.commcare.session.SessionDescriptorUtil;
 import org.commcare.session.SessionFrame;
@@ -121,28 +122,16 @@ public SessionStateDescriptor getExistingIncompleteCaseDescriptor() {
             return null;
         }
 
-        SqlStorage<FormRecord> storage =
-                CommCareApplication.instance().getUserStorage(FormRecord.class);
-
         SqlStorage<SessionStateDescriptor> sessionStorage =
                 CommCareApplication.instance().getUserStorage(SessionStateDescriptor.class);
 
-        // TODO: This is really a join situation. Need a way to outline
-        // connections between tables to enable joining
+        // TODO: This is really a join situation. Need a way to outline connections between tables to enable joining
 
         // See if this session's unique hash corresponds to any pending forms.
         Vector<Integer> ids = sessionStorage.getIDsForValue(SessionStateDescriptor.META_DESCRIPTOR_HASH, ssd.getHash());
-
-        // Filter for forms which have actually been started.
         for (int id : ids) {
             try {
-                int recordId = Integer.valueOf(sessionStorage.getMetaDataFieldForRecord(id, SessionStateDescriptor.META_FORM_RECORD_ID));
-                if (!storage.exists(recordId)) {
-                    sessionStorage.remove(id);
-                    Log.d(TAG, "Removing stale ssd record: " + id);
-                    continue;
-                }
-                if (FormRecord.STATUS_INCOMPLETE.equals(storage.getMetaDataFieldForRecord(recordId, FormRecord.META_STATUS))) {
+                if (ssdHasValidFormRecordId(id, sessionStorage)) {
                     return sessionStorage.read(id);
                 }
             } catch (NumberFormatException nfe) {
@@ -152,6 +141,47 @@ public SessionStateDescriptor getExistingIncompleteCaseDescriptor() {
         return null;
     }
 
+    /**
+     * @return
+     */
+    public static SessionStateDescriptor getFormStateForInterruptedUserSession() {
+        int idOfInterrupted = HiddenPreferences.getIdOfInterruptedSSD();
+        if (idOfInterrupted == -1) {
+            return null;
+        }
+        SqlStorage<SessionStateDescriptor> sessionStorage =
+                CommCareApplication.instance().getUserStorage(SessionStateDescriptor.class);
+        SessionStateDescriptor interrupted = sessionStorage.read(idOfInterrupted);
+        return interrupted;
+    }
+
+    private static boolean ssdHasValidFormRecordId(int ssdId,
+                                                   SqlStorage<SessionStateDescriptor> sessionStorage) {
+        SqlStorage<FormRecord> formRecordStorage =
+                CommCareApplication.instance().getUserStorage(FormRecord.class);
+
+        int correspondingFormRecordId = Integer.valueOf(
+                sessionStorage.getMetaDataFieldForRecord(ssdId, SessionStateDescriptor.META_FORM_RECORD_ID));
+
+        if (!formRecordStorage.exists(correspondingFormRecordId)) {
+            sessionStorage.remove(ssdId);
+            Log.d(TAG, "Removing stale ssd record: " + ssdId);
+            return false;
+        }
+
+        return FormRecord.STATUS_INCOMPLETE.equals(
+                formRecordStorage.getMetaDataFieldForRecord(correspondingFormRecordId, FormRecord.META_STATUS));
+    }
+
+    public void setCurrentStateAsInterrupted() {
+        if (sessionStateRecordId != -1) {
+            SqlStorage<SessionStateDescriptor> sessionStorage =
+                    CommCareApplication.instance().getUserStorage(SessionStateDescriptor.class);
+            SessionStateDescriptor current = sessionStorage.read(sessionStateRecordId);
+            HiddenPreferences.setInterruptedSSD(current.getID());
+        }
+    }
+
     public void commitStub() {
         //TODO: This should now be locked somehow
         SqlStorage<FormRecord> storage = CommCareApplication.instance().getUserStorage(FormRecord.class);

app/src/org/commcare/preferences/HiddenPreferences.java

@@ -28,6 +28,7 @@ public class HiddenPreferences {
     public final static String LAST_UPDATE_ATTEMPT = "cc-last_up";
     public final static String LAST_SYNC_ATTEMPT = "last-ota-restore";
     public final static String LOG_LAST_DAILY_SUBMIT = "log_prop_last_daily";
+    public final static String ID_OF_INTERRUPTED_SSD = "interrupted-ssd-id";
 
     // Preferences that are only ever set by being sent down from HQ via the profile file
     public final static String AUTO_SYNC_FREQUENCY = "cc-autosync-freq";
@@ -194,4 +195,22 @@ public static void setPostUpdateSyncNeeded(boolean b) {
         CommCareApplication.instance().getCurrentApp().getAppPreferences().edit()
                 .putBoolean(POST_UPDATE_SYNC_NEEDED, b).apply();
     }
+
+    public static void setInterruptedSSD(int ssdId) {
+        String currentUserId = CommCareApplication.instance().getCurrentUserId();
+        CommCareApplication.instance().getCurrentApp().getAppPreferences().edit()
+                .putInt(ID_OF_INTERRUPTED_SSD + currentUserId, ssdId).apply();
+    }
+
+    public static int getIdOfInterruptedSSD() {
+        String currentUserId = CommCareApplication.instance().getCurrentUserId();
+        return CommCareApplication.instance().getCurrentApp().getAppPreferences()
+                .getInt(ID_OF_INTERRUPTED_SSD + currentUserId, -1);
+    }
+
+    public static void clearInterruptedSSD() {
+        String currentUserId = CommCareApplication.instance().getCurrentUserId();
+        CommCareApplication.instance().getCurrentApp().getAppPreferences().edit()
+                .putInt(ID_OF_INTERRUPTED_SSD + currentUserId, -1).apply();
+    }
 }