Merge branch 'readonly-p4-donut' into donut

services/java/com/android/server/PowerManagerService.java

@@ -496,8 +496,10 @@ class PowerManagerService extends IPowerManager.Stub implements LocalPowerManage
     }
 
     public void acquireWakeLock(int flags, IBinder lock, String tag) {
-        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null);
         int uid = Binder.getCallingUid();
+        if (uid != Process.myUid()) {
+            mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null);
+        }
         long ident = Binder.clearCallingIdentity();
         try {
             synchronized (mLocks) {
@@ -554,14 +556,14 @@ class PowerManagerService extends IPowerManager.Stub implements LocalPowerManage
             // by the current state so we never turn it more on than
             // it already is.
             if ((wl.flags & PowerManager.ACQUIRE_CAUSES_WAKEUP) != 0) {
-                reactivateWakeLocksLocked();
+                int oldWakeLockState = mWakeLockState;
+                mWakeLockState = mLocks.reactivateScreenLocksLocked();
                 if (mSpew) {
                     Log.d(TAG, "wakeup here mUserState=0x" + Integer.toHexString(mUserState)
-                            + " mLocks.gatherState()=0x"
+                            + " mWakeLockState=0x"
-                            + Integer.toHexString(mLocks.gatherState())
+                            + Integer.toHexString(mWakeLockState)
-                            + " mWakeLockState=0x" + Integer.toHexString(mWakeLockState));
+                            + " previous wakeLockState=0x" + Integer.toHexString(oldWakeLockState));
                 }
-                mWakeLockState = mLocks.gatherState();
             } else {
                 if (mSpew) {
                     Log.d(TAG, "here mUserState=0x" + Integer.toHexString(mUserState)
@@ -598,7 +600,10 @@ class PowerManagerService extends IPowerManager.Stub implements LocalPowerManage
     }
 
     public void releaseWakeLock(IBinder lock) {
-        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null);
+        int uid = Binder.getCallingUid();
+        if (uid != Process.myUid()) {
+            mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null);
+        }
 
         synchronized (mLocks) {
             releaseWakeLockLocked(lock, false);
@@ -653,17 +658,6 @@ class PowerManagerService extends IPowerManager.Stub implements LocalPowerManage
         }
     }
 
-    private void reactivateWakeLocksLocked()
-    {
-        int N = mLocks.size();
-        for (int i=0; i<N; i++) {
-            WakeLock wl = mLocks.get(i);
-            if (isScreenLock(wl.flags)) {
-                mLocks.get(i).activated = true;
-            }
-        }
-    }
-
     private class PokeLock implements IBinder.DeathRecipient
     {
         PokeLock(int p, IBinder b, String t) {
@@ -1752,8 +1746,7 @@ class PowerManagerService extends IPowerManager.Stub implements LocalPowerManage
                         Binder.restoreCallingIdentity(ident);
                     }
                     
-                    reactivateWakeLocksLocked();
+                    mWakeLockState = mLocks.reactivateScreenLocksLocked();
-                    mWakeLockState = mLocks.gatherState();
                     setPowerState(mUserState | mWakeLockState, noChangeLights, true);
                     setTimeoutLocked(time, SCREEN_BRIGHT);
                 }
@@ -1944,6 +1937,20 @@ class PowerManagerService extends IPowerManager.Stub implements LocalPowerManage
             }
             return result;
         }
+        
+        int reactivateScreenLocksLocked()
+        {
+            int result = 0;
+            int N = this.size();
+            for (int i=0; i<N; i++) {
+                WakeLock wl = this.get(i);
+                if (isScreenLock(wl.flags)) {
+                    wl.activated = true;
+                    result |= wl.minState;
+                }
+            }
+            return result;
+        }
     }
 
     void setPolicy(WindowManagerPolicy p) {

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

@@ -179,6 +179,25 @@ public class WindowManagerService extends IWindowManager.Stub implements Watchdo
     static final int UPDATE_FOCUS_PLACING_SURFACES = 2;
     static final int UPDATE_FOCUS_WILL_PLACE_SURFACES = 3;
     
+    /** The minimum time between dispatching touch events. */
+    int mMinWaitTimeBetweenTouchEvents = 1000 / 35;
+
+    // Last touch event time
+    long mLastTouchEventTime = 0;
+    
+    // Last touch event type
+    int mLastTouchEventType = OTHER_EVENT;
+    
+    // Time to wait before calling useractivity again. This saves CPU usage
+    // when we get a flood of touch events.
+    static final int MIN_TIME_BETWEEN_USERACTIVITIES = 1000;
+
+    // Last time we call user activity
+    long mLastUserActivityCallTime = 0;
+
+    // Last time we updated battery stats 
+    long mLastBatteryStatsCallTime = 0;
+    
     private static final String SYSTEM_SECURE = "ro.secure";
 
     /**
@@ -3694,9 +3713,20 @@ public class WindowManagerService extends IWindowManager.Stub implements Watchdo
     // -------------------------------------------------------------
 
     private final void wakeupIfNeeded(WindowState targetWin, int eventType) {
-        if (targetWin == null ||
+        long curTime = SystemClock.uptimeMillis();
-                targetWin.mAttrs.type != WindowManager.LayoutParams.TYPE_KEYGUARD) {
+
-            mPowerManager.userActivity(SystemClock.uptimeMillis(), false, eventType);
+        if (eventType == LONG_TOUCH_EVENT || eventType == CHEEK_EVENT) {
+            if (mLastTouchEventType == eventType &&
+                    (curTime - mLastUserActivityCallTime) < MIN_TIME_BETWEEN_USERACTIVITIES) {
+                return;
+            }
+            mLastUserActivityCallTime = curTime;
+            mLastTouchEventType = eventType;
+        }
+
+        if (targetWin == null
+                || targetWin.mAttrs.type != WindowManager.LayoutParams.TYPE_KEYGUARD) {
+            mPowerManager.userActivity(curTime, false, eventType, false);
         }
     }
 
@@ -3764,7 +3794,7 @@ public class WindowManagerService extends IWindowManager.Stub implements Watchdo
             // events in such a way, since this means the user is moving the
             // pointer without actually pressing down.  All other cases should
             // be atypical, so let's log them.
-            if (ev.getAction() != MotionEvent.ACTION_MOVE) {
+            if (action != MotionEvent.ACTION_MOVE) {
                 Log.w(TAG, "No window to dispatch pointer action " + ev.getAction());
             }
             if (qev != null) {
@@ -3851,7 +3881,39 @@ public class WindowManagerService extends IWindowManager.Stub implements Watchdo
                 return false;
             }
         } //end if target
-        
+
+        // TODO remove once we settle on a value or make it app specific
+        if (action == MotionEvent.ACTION_DOWN) {
+            int max_events_per_sec = 35;
+            try {
+                max_events_per_sec = Integer.parseInt(SystemProperties
+                        .get("windowsmgr.max_events_per_sec"));
+                if (max_events_per_sec < 1) {
+                    max_events_per_sec = 35;
+                }
+            } catch (NumberFormatException e) {
+            }
+            mMinWaitTimeBetweenTouchEvents = 1000 / max_events_per_sec;
+        }
+
+        /*
+         * Throttle events to minimize CPU usage when there's a flood of events
+         * e.g. constant contact with the screen
+         */
+        if (action == MotionEvent.ACTION_MOVE) {
+            long nextEventTime = mLastTouchEventTime + mMinWaitTimeBetweenTouchEvents;
+            long now = SystemClock.uptimeMillis();
+            if (now < nextEventTime) {
+                try {
+                    Thread.sleep(nextEventTime - now);
+                } catch (InterruptedException e) {
+                }
+                mLastTouchEventTime = nextEventTime;
+            } else {
+                mLastTouchEventTime = now;
+            }
+        }
+
         synchronized(mWindowMap) {
             if (qev != null && action == MotionEvent.ACTION_MOVE) {
                 mKeyWaiter.bindTargetWindowLocked(target,
@@ -4928,7 +4990,7 @@ public class WindowManagerService extends IWindowManager.Stub implements Watchdo
                     }
                     if ((actions & WindowManagerPolicy.ACTION_POKE_USER_ACTIVITY) != 0) {
                         mPowerManager.userActivity(event.when, false,
-                                LocalPowerManager.BUTTON_EVENT);
+                                LocalPowerManager.BUTTON_EVENT, false);
                     }
                     
                     if ((actions & WindowManagerPolicy.ACTION_PASS_TO_USER) != 0) {
@@ -5088,11 +5150,17 @@ public class WindowManagerService extends IWindowManager.Stub implements Watchdo
                             eventType = LocalPowerManager.OTHER_EVENT;
                         }
                         try {
-                            mBatteryStats.noteInputEvent();
+                            long now = SystemClock.uptimeMillis();
+
+                            if ((now - mLastBatteryStatsCallTime)
+                                    >= MIN_TIME_BETWEEN_USERACTIVITIES) {
+                                mLastBatteryStatsCallTime = now;
+                                mBatteryStats.noteInputEvent();
+                            }
                         } catch (RemoteException e) {
                             // Ignore
                         }
-                        mPowerManager.userActivity(curTime, false, eventType);
+                        mPowerManager.userActivity(curTime, false, eventType, false);
                         switch (ev.classType) {
                             case RawInputEvent.CLASS_KEYBOARD:
                                 KeyEvent ke = (KeyEvent)ev.event;