Merge "Optimize handling of scrolled wallpapers" into ics-mr1

Author: chethaase

api/current.txt

@@ -18669,6 +18669,7 @@ package android.service.wallpaper {
     method public void onSurfaceRedrawNeeded(android.view.SurfaceHolder);
     method public void onTouchEvent(android.view.MotionEvent);
     method public void onVisibilityChanged(boolean);
+    method public void setOffsetNotificationsEnabled(boolean);
     method public void setTouchEventsEnabled(boolean);
   }
 

core/java/android/service/wallpaper/WallpaperService.java

@@ -148,7 +148,10 @@ public class Engine {
         int mCurWidth;
         int mCurHeight;
         int mWindowFlags = WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
+        int mWindowPrivateFlags =
+                WindowManager.LayoutParams.PRIVATE_FLAG_WANTS_OFFSET_NOTIFICATIONS;
         int mCurWindowFlags = mWindowFlags;
+        int mCurWindowPrivateFlags = mWindowPrivateFlags;
         final Rect mVisibleInsets = new Rect();
         final Rect mWinFrame = new Rect();
         final Rect mContentInsets = new Rect();
@@ -359,6 +362,25 @@ public void setTouchEventsEnabled(boolean enabled) {
                 updateSurface(false, false, false);
             }
         }
+
+        /**
+         * Control whether this wallpaper will receive notifications when the wallpaper
+         * has been scrolled. By default, wallpapers will receive notifications, although
+         * the default static image wallpapers do not. It is a performance optimization to
+         * set this to false.
+         *
+         * @param enabled whether the wallpaper wants to receive offset notifications
+         */
+        public void setOffsetNotificationsEnabled(boolean enabled) {
+            mWindowPrivateFlags = enabled
+                    ? (mWindowPrivateFlags |
+                        WindowManager.LayoutParams.PRIVATE_FLAG_WANTS_OFFSET_NOTIFICATIONS)
+                    : (mWindowPrivateFlags &
+                        ~WindowManager.LayoutParams.PRIVATE_FLAG_WANTS_OFFSET_NOTIFICATIONS);
+            if (mCreated) {
+                updateSurface(false, false, false);
+            }
+        }
 
         /**
          * Called once to initialize the engine.  After returning, the
@@ -478,6 +500,8 @@ protected void dump(String prefix, FileDescriptor fd, PrintWriter out, String[]
             out.print(prefix); out.print("mType="); out.print(mType);
                     out.print(" mWindowFlags="); out.print(mWindowFlags);
                     out.print(" mCurWindowFlags="); out.println(mCurWindowFlags);
+                    out.print(" mWindowPrivateFlags="); out.print(mWindowPrivateFlags);
+                    out.print(" mCurWindowPrivateFlags="); out.println(mCurWindowPrivateFlags);
             out.print(prefix); out.print("mVisibleInsets=");
                     out.print(mVisibleInsets.toShortString());
                     out.print(" mWinFrame="); out.print(mWinFrame.toShortString());
@@ -528,7 +552,8 @@ void updateSurface(boolean forceRelayout, boolean forceReport, boolean redrawNee
             final boolean formatChanged = mFormat != mSurfaceHolder.getRequestedFormat();
             boolean sizeChanged = mWidth != myWidth || mHeight != myHeight;
             final boolean typeChanged = mType != mSurfaceHolder.getRequestedType();
-            final boolean flagsChanged = mCurWindowFlags != mWindowFlags;
+            final boolean flagsChanged = mCurWindowFlags != mWindowFlags ||
+                    mCurWindowPrivateFlags != mWindowPrivateFlags;
             if (forceRelayout || creating || surfaceCreating || formatChanged || sizeChanged
                     || typeChanged || flagsChanged || redrawNeeded) {
 
@@ -554,6 +579,8 @@ void updateSurface(boolean forceRelayout, boolean forceReport, boolean redrawNee
                             | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
                             | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
                             ;
+                    mCurWindowPrivateFlags = mWindowPrivateFlags;
+                    mLayout.privateFlags = mWindowPrivateFlags;
 
                     mLayout.memoryType = mType;
                     mLayout.token = mWindowToken;

core/java/android/view/WindowManager.java

@@ -812,6 +812,17 @@ public static class LayoutParams extends ViewGroup.LayoutParams
          */
         public static final int PRIVATE_FLAG_FORCE_HARDWARE_ACCELERATED = 0x00000002;
 
+        /**
+         * By default, wallpapers are sent new offsets when the wallpaper is scrolled. Wallpapers
+         * may elect to skp these notifications if they are no doing anything productive with
+         * them (they do not affect the wallpaper scrolling operation) by calling
+         * {@link
+         * android.service.wallpaper.WallpaperService.Engine#setOffsetNotificationsEnabled(boolean)}.
+         *
+         * @hide
+         */
+        public static final int PRIVATE_FLAG_WANTS_OFFSET_NOTIFICATIONS = 0x00000004;
+
         /**
          * Control flags that are private to the platform.
          * @hide

packages/SystemUI/src/com/android/systemui/ImageWallpaper.java

@@ -170,6 +170,8 @@ public void onCreate(SurfaceHolder surfaceHolder) {
             //registerReceiver(mReceiver, filter, null, mHandler);
 
             updateSurfaceSize(surfaceHolder);
+
+            setOffsetNotificationsEnabled(false);
         }
 
         @Override

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

@@ -1836,7 +1836,8 @@ boolean updateWallpaperOffsetLocked(WindowState wallpaperWin, int dw, int dh,
             rawChanged = true;
         }
 
-        if (rawChanged) {
+        if (rawChanged && (wallpaperWin.getAttrs().privateFlags &
+                    WindowManager.LayoutParams.PRIVATE_FLAG_WANTS_OFFSET_NOTIFICATIONS) != 0) {
             try {
                 if (DEBUG_WALLPAPER) Slog.v(TAG, "Report new wp offset "
                         + wallpaperWin + " x=" + wallpaperWin.mWallpaperX
@@ -1886,12 +1887,10 @@ void wallpaperOffsetsComplete(IBinder window) {
         }
     }
 
-    boolean updateWallpaperOffsetLocked(WindowState changingTarget, boolean sync) {
+    void updateWallpaperOffsetLocked(WindowState changingTarget, boolean sync) {
         final int dw = mAppDisplayWidth;
         final int dh = mAppDisplayHeight;
 
-        boolean changed = false;
-
         WindowState target = mWallpaperTarget;
         if (target != null) {
             if (target.mWallpaperX >= 0) {
@@ -1916,14 +1915,31 @@ boolean updateWallpaperOffsetLocked(WindowState changingTarget, boolean sync) {
                 WindowState wallpaper = token.windows.get(curWallpaperIndex);
                 if (updateWallpaperOffsetLocked(wallpaper, dw, dh, sync)) {
                     wallpaper.computeShownFrameLocked();
-                    changed = true;
+                    // No need to lay out the windows - we can just set the wallpaper position
+                    // directly.
+                    if (wallpaper.mSurfaceX != wallpaper.mShownFrame.left
+                            || wallpaper.mSurfaceY != wallpaper.mShownFrame.top) {
+                        Surface.openTransaction();
+                        try {
+                            if (SHOW_TRANSACTIONS) logSurface(wallpaper,
+                                    "POS " + wallpaper.mShownFrame.left
+                                    + ", " + wallpaper.mShownFrame.top, null);
+                            wallpaper.mSurfaceX = wallpaper.mShownFrame.left;
+                            wallpaper.mSurfaceY = wallpaper.mShownFrame.top;
+                            wallpaper.mSurface.setPosition(wallpaper.mShownFrame.left,
+                                    wallpaper.mShownFrame.top);
+                        } catch (RuntimeException e) {
+                            Slog.w(TAG, "Error positioning surface of " + wallpaper
+                                    + " pos=(" + wallpaper.mShownFrame.left
+                                    + "," + wallpaper.mShownFrame.top + ")", e);
+                        }
+                        Surface.closeTransaction();
+                    }
                     // We only want to be synchronous with one wallpaper.
                     sync = false;
                 }
             }
         }
-
-        return changed;
     }
 
     void updateWallpaperVisibilityLocked() {
@@ -2436,9 +2452,7 @@ public void setWindowWallpaperPositionLocked(WindowState window, float x, float
             window.mWallpaperY = y;
             window.mWallpaperXStep = xStep;
             window.mWallpaperYStep = yStep;
-            if (updateWallpaperOffsetLocked(window, true)) {
-                performLayoutAndPlaceSurfacesLocked();
-            }
+            updateWallpaperOffsetLocked(window, true);
         }
     }