Separate animation steps into start, step and finish phases.

Fixes bug 6089126.

Change-Id: Iafbde36ff719640335a7ecf762e1d991cf7915e4

Author: Craig Mautner

services/java/com/android/server/wm/AppWindowToken.java

@@ -37,7 +37,7 @@
  * Version of WindowToken that is specifically for a particular application (or
  * really activity) that is displaying windows.
  */
-class AppWindowToken extends WindowToken {
+class AppWindowToken extends WindowToken implements WindowManagerService.StepAnimator {
     // Non-null only for application tokens.
     final IApplicationToken appToken;
 
@@ -195,8 +195,28 @@ void showAllWindowsLocked() {
         }
     }
 
+    @Override
+    public boolean stepAnimation(long currentTime) {
+        if (animation == null) {
+            return false;
+        }
+        transformation.clear();
+        final boolean more = animation.getTransformation(currentTime, transformation);
+        if (WindowManagerService.DEBUG_ANIM) Slog.v(
+            WindowManagerService.TAG, "Stepped animation in " + this +
+            ": more=" + more + ", xform=" + transformation);
+        if (!more) {
+            animation = null;
+            if (WindowManagerService.DEBUG_ANIM) Slog.v(
+                WindowManagerService.TAG, "Finished animation in " + this +
+                " @ " + currentTime);
+        }
+        hasTransformation = more;
+        return more;
+    }
+
     // This must be called while inside a transaction.
-    boolean stepAnimationLocked(long currentTime, int dw, int dh) {
+    boolean startAndFinishAnimationLocked(long currentTime, int dw, int dh) {
         if (!service.mDisplayFrozen && service.mPolicy.isScreenOnFully()) {
             // We will run animations as long as the display isn't frozen.
 
@@ -219,21 +239,8 @@ boolean stepAnimationLocked(long currentTime, int dw, int dh) {
                     animation.setStartTime(currentTime);
                     animating = true;
                 }
-                transformation.clear();
-                final boolean more = animation.getTransformation(
-                    currentTime, transformation);
-                if (WindowManagerService.DEBUG_ANIM) Slog.v(
-                    WindowManagerService.TAG, "Stepped animation in " + this +
-                    ": more=" + more + ", xform=" + transformation);
-                if (more) {
-                    // we're done!
-                    hasTransformation = true;
-                    return true;
-                }
-                if (WindowManagerService.DEBUG_ANIM) Slog.v(
-                    WindowManagerService.TAG, "Finished animation in " + this +
-                    " @ " + currentTime);
-                animation = null;
+                // we're done!
+                return true;
             }
         } else if (animation != null) {
             // If the display is frozen, and there is a pending animation,
@@ -369,6 +376,7 @@ WindowState findMainWindow() {
         return null;
     }
 
+    @Override
     void dump(PrintWriter pw, String prefix) {
         super.dump(pw, prefix);
         if (appToken != null) {

services/java/com/android/server/wm/ScreenRotationAnimation.java

@@ -29,7 +29,7 @@
 import android.view.animation.AnimationUtils;
 import android.view.animation.Transformation;
 
-class ScreenRotationAnimation {
+class ScreenRotationAnimation implements WindowManagerService.StepAnimator {
     static final String TAG = "ScreenRotationAnimation";
     static final boolean DEBUG_STATE = false;
     static final boolean DEBUG_TRANSFORMS = false;
@@ -97,6 +97,12 @@ class ScreenRotationAnimation {
     final Matrix mSnapshotFinalMatrix = new Matrix();
     final Matrix mTmpMatrix = new Matrix();
     final float[] mTmpFloats = new float[9];
+    private boolean mMoreRotateEnter;
+    private boolean mMoreRotateExit;
+    private boolean mMoreFinishEnter;
+    private boolean mMoreFinishExit;
+    private boolean mMoreStartEnter;
+    private boolean mMoreStartExit;
 
     public void printTo(String prefix, PrintWriter pw) {
         pw.print(prefix); pw.print("mSurface="); pw.print(mSurface);
@@ -456,34 +462,8 @@ public boolean isAnimating() {
                 && mRotateEnterAnimation != null || mRotateExitAnimation != null;
     }
 
+    @Override
     public boolean stepAnimation(long now) {
-        if (!isAnimating()) {
-            if (DEBUG_STATE) Slog.v(TAG, "Step: no animations running");
-            return false;
-        }
-
-        if (!mAnimRunning) {
-            if (DEBUG_STATE) Slog.v(TAG, "Step: starting start, finish, rotate");
-            if (mStartEnterAnimation != null) {
-                mStartEnterAnimation.setStartTime(now);
-            }
-            if (mStartExitAnimation != null) {
-                mStartExitAnimation.setStartTime(now);
-            }
-            if (mFinishEnterAnimation != null) {
-                mFinishEnterAnimation.setStartTime(0);
-            }
-            if (mFinishExitAnimation != null) {
-                mFinishExitAnimation.setStartTime(0);
-            }
-            if (mRotateEnterAnimation != null) {
-                mRotateEnterAnimation.setStartTime(now);
-            }
-            if (mRotateExitAnimation != null) {
-                mRotateExitAnimation.setStartTime(now);
-            }
-            mAnimRunning = true;
-        }
 
         if (mFinishAnimReady && mFinishAnimStartTime < 0) {
             if (DEBUG_STATE) Slog.v(TAG, "Step: finish anim now ready");
@@ -493,24 +473,24 @@ public boolean stepAnimation(long now) {
         // If the start animation is no longer running, we want to keep its
         // transformation intact until the finish animation also completes.
 
-        boolean moreStartExit = false;
+        mMoreStartExit = false;
         if (mStartExitAnimation != null) {
             mStartExitTransformation.clear();
-            moreStartExit = mStartExitAnimation.getTransformation(now, mStartExitTransformation);
+            mMoreStartExit = mStartExitAnimation.getTransformation(now, mStartExitTransformation);
             if (DEBUG_TRANSFORMS) Slog.v(TAG, "Stepped start exit: " + mStartExitTransformation);
-            if (!moreStartExit) {
+            if (!mMoreStartExit) {
                 if (DEBUG_STATE) Slog.v(TAG, "Start exit animation done!");
                 mStartExitAnimation.cancel();
                 mStartExitAnimation = null;
             }
         }
 
-        boolean moreStartEnter = false;
+        mMoreStartEnter = false;
         if (mStartEnterAnimation != null) {
             mStartEnterTransformation.clear();
-            moreStartEnter = mStartEnterAnimation.getTransformation(now, mStartEnterTransformation);
+            mMoreStartEnter = mStartEnterAnimation.getTransformation(now, mStartEnterTransformation);
             if (DEBUG_TRANSFORMS) Slog.v(TAG, "Stepped start enter: " + mStartEnterTransformation);
-            if (!moreStartEnter) {
+            if (!mMoreStartEnter) {
                 if (DEBUG_STATE) Slog.v(TAG, "Start enter animation done!");
                 mStartEnterAnimation.cancel();
                 mStartEnterAnimation = null;
@@ -521,11 +501,11 @@ public boolean stepAnimation(long now) {
         if (DEBUG_STATE) Slog.v(TAG, "Step: finishNow=" + finishNow);
 
         mFinishExitTransformation.clear();
-        boolean moreFinishExit = false;
+        mMoreFinishExit = false;
         if (mFinishExitAnimation != null) {
-            moreFinishExit = mFinishExitAnimation.getTransformation(finishNow, mFinishExitTransformation);
+            mMoreFinishExit = mFinishExitAnimation.getTransformation(finishNow, mFinishExitTransformation);
             if (DEBUG_TRANSFORMS) Slog.v(TAG, "Stepped finish exit: " + mFinishExitTransformation);
-            if (!moreStartExit && !moreFinishExit) {
+            if (!mMoreStartExit && !mMoreFinishExit) {
                 if (DEBUG_STATE) Slog.v(TAG, "Finish exit animation done, clearing start/finish anims!");
                 mStartExitTransformation.clear();
                 mFinishExitAnimation.cancel();
@@ -535,11 +515,11 @@ public boolean stepAnimation(long now) {
         }
 
         mFinishEnterTransformation.clear();
-        boolean moreFinishEnter = false;
+        mMoreFinishEnter = false;
         if (mFinishEnterAnimation != null) {
-            moreFinishEnter = mFinishEnterAnimation.getTransformation(finishNow, mFinishEnterTransformation);
+            mMoreFinishEnter = mFinishEnterAnimation.getTransformation(finishNow, mFinishEnterTransformation);
             if (DEBUG_TRANSFORMS) Slog.v(TAG, "Stepped finish enter: " + mFinishEnterTransformation);
-            if (!moreStartEnter && !moreFinishEnter) {
+            if (!mMoreStartEnter && !mMoreFinishEnter) {
                 if (DEBUG_STATE) Slog.v(TAG, "Finish enter animation done, clearing start/finish anims!");
                 mStartEnterTransformation.clear();
                 mFinishEnterAnimation.cancel();
@@ -549,27 +529,27 @@ public boolean stepAnimation(long now) {
         }
 
         mRotateExitTransformation.clear();
-        boolean moreRotateExit = false;
+        mMoreRotateExit = false;
         if (mRotateExitAnimation != null) {
-            moreRotateExit = mRotateExitAnimation.getTransformation(now, mRotateExitTransformation);
+            mMoreRotateExit = mRotateExitAnimation.getTransformation(now, mRotateExitTransformation);
             if (DEBUG_TRANSFORMS) Slog.v(TAG, "Stepped rotate exit: " + mRotateExitTransformation);
         }
 
-        if (!moreFinishExit && !moreRotateExit) {
+        if (!mMoreFinishExit && !mMoreRotateExit) {
             if (DEBUG_STATE) Slog.v(TAG, "Rotate exit animation done!");
             mRotateExitAnimation.cancel();
             mRotateExitAnimation = null;
             mRotateExitTransformation.clear();
         }
 
         mRotateEnterTransformation.clear();
-        boolean moreRotateEnter = false;
+        mMoreRotateEnter = false;
         if (mRotateEnterAnimation != null) {
-            moreRotateEnter = mRotateEnterAnimation.getTransformation(now, mRotateEnterTransformation);
+            mMoreRotateEnter = mRotateEnterAnimation.getTransformation(now, mRotateEnterTransformation);
             if (DEBUG_TRANSFORMS) Slog.v(TAG, "Stepped rotate enter: " + mRotateEnterTransformation);
         }
 
-        if (!moreFinishEnter && !moreRotateEnter) {
+        if (!mMoreFinishEnter && !mMoreRotateEnter) {
             if (DEBUG_STATE) Slog.v(TAG, "Rotate enter animation done!");
             mRotateEnterAnimation.cancel();
             mRotateEnterAnimation = null;
@@ -587,14 +567,25 @@ public boolean stepAnimation(long now) {
         if (DEBUG_TRANSFORMS) Slog.v(TAG, "Final exit: " + mExitTransformation);
         if (DEBUG_TRANSFORMS) Slog.v(TAG, "Final enter: " + mEnterTransformation);
 
-        if (!moreStartExit && !moreFinishExit && !moreRotateExit) {
+        final boolean more = mMoreStartEnter || mMoreStartExit || mMoreFinishEnter
+                || mMoreFinishExit || mMoreRotateEnter || mMoreRotateExit || !mFinishAnimReady;
+
+        mSnapshotFinalMatrix.setConcat(mExitTransformation.getMatrix(), mSnapshotInitialMatrix);
+
+        if (DEBUG_STATE) Slog.v(TAG, "Step: more=" + more);
+
+        return more;
+    }
+
+    void updateSurfaces() {
+        if (!mMoreStartExit && !mMoreFinishExit && !mMoreRotateExit) {
             if (mSurface != null) {
                 if (DEBUG_STATE) Slog.v(TAG, "Exit animations done, hiding screenshot surface");
                 mSurface.hide();
             }
         }
 
-        if (!moreStartEnter && !moreFinishEnter && !moreRotateEnter) {
+        if (!mMoreStartEnter && !mMoreFinishEnter && !mMoreRotateEnter) {
             if (mBlackFrame != null) {
                 if (DEBUG_STATE) Slog.v(TAG, "Enter animations done, hiding black frame");
                 mBlackFrame.hide();
@@ -605,15 +596,39 @@ public boolean stepAnimation(long now) {
             }
         }
 
-        mSnapshotFinalMatrix.setConcat(mExitTransformation.getMatrix(), mSnapshotInitialMatrix);
         setSnapshotTransform(mSnapshotFinalMatrix, mExitTransformation.getAlpha());
+    }
+    
+    public boolean startAndFinishAnimationLocked(long now) {
+        if (!isAnimating()) {
+            if (DEBUG_STATE) Slog.v(TAG, "Step: no animations running");
+            return false;
+        }
 
-        final boolean more = moreStartEnter || moreStartExit || moreFinishEnter || moreFinishExit
-                || moreRotateEnter || moreRotateExit || !mFinishAnimReady;
-
-        if (DEBUG_STATE) Slog.v(TAG, "Step: more=" + more);
-
-        return more;
+        if (!mAnimRunning) {
+            if (DEBUG_STATE) Slog.v(TAG, "Step: starting start, finish, rotate");
+            if (mStartEnterAnimation != null) {
+                mStartEnterAnimation.setStartTime(now);
+            }
+            if (mStartExitAnimation != null) {
+                mStartExitAnimation.setStartTime(now);
+            }
+            if (mFinishEnterAnimation != null) {
+                mFinishEnterAnimation.setStartTime(0);
+            }
+            if (mFinishExitAnimation != null) {
+                mFinishExitAnimation.setStartTime(0);
+            }
+            if (mRotateEnterAnimation != null) {
+                mRotateEnterAnimation.setStartTime(now);
+            }
+            if (mRotateExitAnimation != null) {
+                mRotateExitAnimation.setStartTime(now);
+            }
+            mAnimRunning = true;
+        }
+        
+        return true;
     }
 
     public Transformation getEnterTransformation() {