am 3f857b78: Merge change I32d41651 into eclair

Merge commit '3f857b78fc68e5d700139bdc6078c5333b62a9bc' into eclair-plus-aosp

* commit '3f857b78fc68e5d700139bdc6078c5333b62a9bc':
  Allow a GLThread to release and reacquire the EGL Surface as needed.

1 files changed, 46 insertions, 32 deletions

diff --git a/opengl/java/android/opengl/GLSurfaceView.java b/opengl/java/android/opengl/GLSurfaceView.java
index ac27a2d..0330163 100644
--- a/opengl/java/android/opengl/GLSurfaceView.java
+++ b/opengl/java/android/opengl/GLSurfaceView.java
@@ -971,33 +971,41 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
              * accesses EGL.
              */
             try {
-                try {
-                    sGLThreadManager.start(this);
-                } catch (InterruptedException e) {
-                    return;
-                }
                 guardedRun();
             } catch (InterruptedException e) {
                 // fall thru and exit normally
             } finally {
-                try {
-                    sGLThreadManager.end(this);
-                } finally {
-                    synchronized(this) {
-                        if (LOG_THREADS) {
-                            Log.i("GLThread", "exiting tid=" +  getId());
-                        }
-                        mDone = true;
-                        notifyAll();
+                synchronized(this) {
+                    if (LOG_THREADS) {
+                        Log.i("GLThread", "exiting tid=" +  getId());
                     }
+                    mDone = true;
+                    notifyAll();
                 }
             }
         }
 
+        private void startEgl() throws InterruptedException {
+            if (! mHaveEgl) {
+                mHaveEgl = true;
+                sGLThreadManager.start(this);
+                mEglHelper.start();
+            }
+        }
+
+        private void stopEgl() {
+            if (mHaveEgl) {
+                mHaveEgl = false;
+                mEglHelper.destroySurface();
+                mEglHelper.finish();
+                sGLThreadManager.end(this);
+            }
+        }
+
         private void guardedRun() throws InterruptedException {
             mEglHelper = new EglHelper();
             try {
-                mEglHelper.start();
+                startEgl();
 
                 GL10 gl = null;
                 boolean tellRendererSurfaceCreated = true;
@@ -1021,20 +1029,30 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
                             r.run();
                         }
                         if (mPaused) {
-                            mEglHelper.destroySurface();
-                            mEglHelper.finish();
+                            stopEgl();
                             needStart = true;
                         }
-                        while (needToWait()) {
-                            if (LOG_THREADS) {
-                                Log.i("GLThread", "needToWait tid=" + getId());
-                            }
+                        while(true) {
                             if (!mHasSurface) {
                                 if (!mWaitingForSurface) {
-                                    mEglHelper.destroySurface();
+                                    stopEgl();
                                     mWaitingForSurface = true;
                                     notifyAll();
                                 }
+                            } else {
+                                boolean shouldHaveEgl = sGLThreadManager.shouldHaveEgl(this);
+                                if (mHaveEgl && (!shouldHaveEgl)) {
+                                    stopEgl();
+                                } else if ((!mHaveEgl) && shouldHaveEgl) {
+                                    startEgl();
+                                    needStart = true;
+                                }
+                            }
+                            if (!needToWait()) {
+                                break;
+                            }
+                            if (LOG_THREADS) {
+                                Log.i("GLThread", "needToWait tid=" + getId());
                             }
                             wait();
                         }
@@ -1053,7 +1071,7 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
                         }
                     }
                     if (needStart) {
-                        mEglHelper.start();
+                        startEgl();
                         tellRendererSurfaceCreated = true;
                         changed = true;
                     }
@@ -1084,21 +1102,16 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
                 /*
                  * clean-up everything...
                  */
-                mEglHelper.destroySurface();
-                mEglHelper.finish();
+                stopEgl();
             }
         }
 
         private boolean needToWait() {
-            if (sGLThreadManager.shouldQuit(this)) {
-                mDone = true;
-                notifyAll();
-            }
             if (mDone) {
                 return false;
             }
 
-            if (mPaused || (! mHasSurface)) {
+            if (mPaused || (! mHasSurface) || (! mHaveEgl)) {
                 return true;
             }
 
@@ -1223,6 +1236,7 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
         private boolean mPaused;
         private boolean mHasSurface;
         private boolean mWaitingForSurface;
+        private boolean mHaveEgl;
         private int mWidth;
         private int mHeight;
         private int mRenderMode;
@@ -1273,9 +1287,9 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
     }
 
     static class GLThreadManager {
-        public boolean shouldQuit(GLThread thread) {
+        public boolean shouldHaveEgl(GLThread thread) {
             synchronized(this) {
-                return thread != mMostRecentGLThread;
+                return thread == mMostRecentGLThread || mMostRecentGLThread == null;
             }
         }
         public void start(GLThread thread) throws InterruptedException {