handle resuming in no-loop state

Author: codeanticode

core/src/processing/a2d/PGraphicsAndroid2D.java

@@ -127,13 +127,6 @@ public class PGraphicsAndroid2D extends PGraphics {
 
   //////////////////////////////////////////////////////////////
 
-  /** To save the surface contents before the activity is taken to the background. */
-  private String restoreFilename;
-  private int restoreWidth, restoreHeight;
-  private int restoreCount;
-
-  //////////////////////////////////////////////////////////////
-
   // INTERNAL
 
 
@@ -2064,6 +2057,8 @@ public void resize(int wide, int high) {
 
   @Override
   protected void saveState() {
+    super.saveState();
+
     Context context = parent.getContext();
     if (context == null || bitmap == null || parent.getSurface().getComponent().isService()) return;
     try {
@@ -2094,11 +2089,6 @@ protected void saveState() {
   }
 
 
-  @Override
-  protected void restoreState() {
-  }
-
-
   @Override
   protected void restoreSurface() {
     if (changed) {
@@ -2125,15 +2115,18 @@ protected void restoreSurface() {
           }
           inStream.close();
           cacheFile.delete();
-          restoreFilename = null;
-          restoreWidth = -1;
-          restoreHeight = -1;
         } catch (Exception ex) {
           PGraphics.showWarning("Could not restore screen contents from cache");
           ex.printStackTrace();
+        } finally {
+          restoreFilename = null;
+          restoreWidth = -1;
+          restoreHeight = -1;
+          restoredSurface = true;
         }
       }
     }
+    super.restoreSurface();
   }
 
 

core/src/processing/core/PApplet.java

@@ -558,27 +558,25 @@ public void onResume() {
       setFullScreenVisibility();
     }
 
-    if (g != null) {
-      g.restoreState();
-    }
-
     handleMethods("resume");
 
+    // Don't call resume() when the app is starting and setup() has not been called yet:
+    // https://github.com/processing/processing-android/issues/274
+    // Also, there is no need to call resume() from anywhere else (for example, from
+    // onStart) since onResume() is always called in the activity lifecyle:
+    // https://developer.android.com/guide/components/activities/activity-lifecycle.html
     if (0 < frameCount) {
-      // Don't call resume() when the app is starting and setup() has not been
-      // called yet
-      // https://github.com/processing/processing-android/issues/274
-
-      // Also, no need to call resume() from anywhere else (for example, from
-      // onStart) since onResume() is always called in the activity lifecyle:
-      // https://developer.android.com/guide/components/activities/activity-lifecycle.html
       resume();
     }
 
-    // Set the default to true to handle the situation where a fragment is popping back
-    // after pressing back (app does not exit)
+    // Set the handledBackPressed to true to handle the situation where a fragment is popping
+    // right back after pressing the back button (the sketch does not exit).
     handledBackPressed = true;
 
+    if (g != null) {
+      g.restoreState();
+    }
+
     surface.resumeThread();
   }
 
@@ -1838,22 +1836,10 @@ public void handleDraw() {
 //      recorder.beginDraw();
 //    }
 
-    if (requestedNoLoop) {
-      // noLoop() was called sometime in the previous frame with a GL renderer, but only now
-      // we are sure that the frame is properly displayed.
-      looping = false;
-      // Perform a full frame draw, to ensure that the previous frame is properly displayed (see
-      // comment in the declaration of requestedNoLoop).
-      g.beginDraw();
-      g.endDraw();
-      requestedNoLoop = false;
-      insideDraw = false;
-      return;
-    }
+    if (handleSpecialDraw()) return;
 
     g.beginDraw();
 
-
     long now = System.nanoTime();
 
     if (frameCount == 0) {
@@ -1909,6 +1895,41 @@ public void handleDraw() {
   }
 
 
+  // This method handles some special situations on Android where beginDraw/endDraw are needed,
+  // but not to render the actualy contents of draw(). In general, this situations arise from
+  // having to refresh/restore the screen after requesting no loop, or resuming the sketch in
+  // no-loop state.
+  protected boolean handleSpecialDraw() {
+    boolean handled = false;
+
+    if (g.restoringState()) {
+      // The sketch is restoring, so begin/end the frame properly and quit drawing.
+      g.beginDraw();
+      g.endDraw();
+
+      handled = true;
+    } else if (requestedNoLoop) {
+      // noLoop() was called sometime in the previous frame with a GL renderer, but only now
+      // we are sure that the frame is properly displayed.
+      looping = false;
+
+      // Perform a full frame draw, to ensure that the previous frame is properly displayed (see
+      // comment in the declaration of requestedNoLoop).
+      g.beginDraw();
+      g.endDraw();
+
+      requestedNoLoop = false;
+      handled = true;
+    }
+
+    if (handled) {
+      insideDraw = false;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
   //////////////////////////////////////////////////////////////
 
 

core/src/processing/core/PGraphics.java

@@ -640,6 +640,14 @@ public class PGraphics extends PImage implements PConstants {
   /// Number of V steps (aka "phi") along latitudinally top-to-bottom spanning pi
   public int sphereDetailV = 0;
 
+  // ........................................................
+
+  // Variables used to save the surface contents before the activity is taken to the background.
+  protected String restoreFilename;
+  protected int restoreWidth, restoreHeight;
+  protected int restoreCount;
+  protected boolean restartedLoopingAfterResume = false;
+  protected boolean restoredSurface = false;
 
   //////////////////////////////////////////////////////////////
 
@@ -969,17 +977,44 @@ protected void reapplySettings() {  // ignore
     reapplySettings = false;
   }
 
+  //////////////////////////////////////////////////////////////
+
+  // RENDERER STATE
 
-  protected void saveState() {  // ignore
 
+  protected void saveState() {  // ignore
+    // Nothing to do here, it depends on the renderer's implementation.
   }
 
   protected void restoreState() {  // ignore
+    // This method probably does not need to be re-implemented in the subclasses. All we need to
+    // do is to check for the resume in no-loop state situation:
+    restoredSurface = false;
+    if (!parent.isLooping()) {
+      // The sketch needs to draw a few frames after resuming so it has the chance to restore the
+      // screen contents:
+      // https://github.com/processing/processing-android/issues/492
+      // so we restart looping:
+      parent.loop();
+      // and flag this situation when the surface has been restored:
+      restartedLoopingAfterResume = true;
+    }
+  }
+
 
+  protected boolean restoringState() { // ignore
+    return !restoredSurface && restartedLoopingAfterResume;
   }
 
-  protected void restoreSurface() { // ignore
 
+  protected void restoreSurface() { // ignore
+    // When implementing this method in a subclass of PGraphics, it should add a call to the super
+    // implementation, to make sure that the looping is stopped in the case where the sketch was
+    // resumed in no-loop state (see comment in restoreState() method above).
+    if (restoredSurface && restartedLoopingAfterResume) {
+      restartedLoopingAfterResume = false;
+      parent.noLoop();
+    }
   }
 
   //////////////////////////////////////////////////////////////

core/src/processing/opengl/PGraphicsOpenGL.java

@@ -515,11 +515,6 @@ public void dispose() {
   static protected IntBuffer intBuffer;
   static protected FloatBuffer floatBuffer;
 
-  /** To save the surface contents before the activity is taken to the background. */
-  private String restoreFilename;
-  private int restoreWidth, restoreHeight;
-  private int restoreCount;
-
   // ........................................................
 
   // Error strings:
@@ -5701,6 +5696,8 @@ protected void drawPixels(int[] pixBuffer, int x, int y, int w, int h) {
 
   @Override
   protected void saveState() {
+    super.saveState();
+
     // Queue the pixel read operation so it is performed when the surface is ready
     pgl.queueEvent(new Runnable() {
       @Override
@@ -5736,11 +5733,6 @@ public void run() {
   }
 
 
-  @Override
-  protected void restoreState() {
-  }
-
-
   @Override
   protected void restoreSurface() {
     if (changed) {
@@ -5775,15 +5767,18 @@ protected void restoreSurface() {
           }
           inStream.close();
           cacheFile.delete();
-          restoreFilename = null;
-          restoreWidth = -1;
-          restoreHeight = -1;
         } catch (Exception ex) {
           PGraphics.showWarning("Could not restore screen contents from cache");
           ex.printStackTrace();
+        } finally {
+          restoreFilename = null;
+          restoreWidth = -1;
+          restoreHeight = -1;
+          restoredSurface = true;
         }
       }
     }
+    super.restoreSurface();
   }
 
   //////////////////////////////////////////////////////////////