First stab at device idle mode.

Introduce a new device idle controller service that
monitor's the device state and determines when to go
in to idle mode.  When in idle mode, all we do right
now is turn off network access the same as we do for
power save mode.  Many more things should come in the
future -- stopping the alarm manager from scheduling
(most) alarms, telling GmsCore for it to stop doing
stuff, etc.

Battery stats now has state tracking for devie idle
mode, as well as events for the reasons we can come
out of idle mode (significant motion or the device
becoming active).  Also added new events noting when
packages are installed.

Renamed the "low power" event in battery stats to
"power save" because the former was just way too
confusing.

Finally, fix buffer size reading kernel wake locks.
(Stupidly, just increasing the buffer size.  Ideally
we should try to be smarter and grow our buffer to
fit the data available, but I'll leave that for
another time.)

Change-Id: I0be2062466c83ee9d890c6cf5a228d9cc4090eca

6 files changed, 485 insertions, 9 deletions

diff --git a/services/core/java/com/android/server/DeviceIdleController.java b/services/core/java/com/android/server/DeviceIdleController.java
new file mode 100644
index 0000000..062992d
--- /dev/null
+++ b/services/core/java/com/android/server/DeviceIdleController.java
@@ -0,0 +1,424 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server;
+
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.PackageManager;
+import android.hardware.Sensor;
+import android.hardware.SensorManager;
+import android.hardware.TriggerEvent;
+import android.hardware.TriggerEventListener;
+import android.hardware.display.DisplayManager;
+import android.net.INetworkPolicyManager;
+import android.os.Binder;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.os.SystemClock;
+import android.util.TimeUtils;
+import android.view.Display;
+import com.android.internal.app.IBatteryStats;
+import com.android.server.am.BatteryStatsService;
+
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+
+/**
+ * Keeps track of device idleness and drives low power mode based on that.
+ */
+public class DeviceIdleController extends SystemService {
+    private static final String TAG = "DeviceIdleController";
+
+    private static final String ACTION_STEP_IDLE_STATE =
+            "com.android.server.device_idle.STEP_IDLE_STATE";
+
+    // TODO: These need to be moved to system settings.
+
+    /**
+     * This is the time, after becoming inactive, at which we start looking at the
+     * motion sensor to determine if the device is being left alone.  We don't do this
+     * immediately after going inactive just because we don't want to be continually running
+     * the significant motion sensor whenever the screen is off.
+     */
+    private static final long DEFAULT_INACTIVE_TIMEOUT = 30*60*1000L;
+    /**
+     * This is the time, after the inactive timeout elapses, that we will wait looking
+     * for significant motion until we truly consider the device to be idle.
+     */
+    private static final long DEFAULT_IDLE_AFTER_INACTIVE_TIMEOUT = 30*60*1000L;
+    /**
+     * This is the initial time, after being idle, that we will allow ourself to be back
+     * in the IDLE_PENDING state allowing the system to run normally until we return to idle.
+     */
+    private static final long DEFAULT_IDLE_PENDING_TIMEOUT = 5*60*1000L;
+    /**
+     * Maximum pending idle timeout (time spent running) we will be allowed to use.
+     */
+    private static final long DEFAULT_MAX_IDLE_PENDING_TIMEOUT = 10*60*1000L;
+    /**
+     * Scaling factor to apply to current pending idle timeout each time we cycle through
+     * that state.
+     */
+    private static final float DEFAULT_IDLE_PENDING_FACTOR = 2f;
+    /**
+     * This is the initial time that we want to sit in the idle state before waking up
+     * again to return to pending idle and allowing normal work to run.
+     */
+    private static final long DEFAULT_IDLE_TIMEOUT = 60*60*1000L;
+    /**
+     * Maximum idle duration we will be allowed to use.
+     */
+    private static final long DEFAULT_MAX_IDLE_TIMEOUT = 6*60*60*1000L;
+    /**
+     * Scaling factor to apply to current idle timeout each time we cycle through that state.
+     */
+    private static final float DEFAULT_IDLE_FACTOR = 2f;
+
+    private AlarmManager mAlarmManager;
+    private IBatteryStats mBatteryStats;
+    private INetworkPolicyManager mNetworkPolicyManager;
+    private DisplayManager mDisplayManager;
+    private SensorManager mSensorManager;
+    private Sensor mSigMotionSensor;
+    private PendingIntent mAlarmIntent;
+    private Display mCurDisplay;
+    private boolean mScreenOn;
+    private boolean mCharging;
+    private boolean mSigMotionActive;
+
+    /** Device is currently active. */
+    private static final int STATE_ACTIVE = 0;
+    /** Device is inactve (screen off, no motion) and we are waiting to for idle. */
+    private static final int STATE_INACTIVE = 1;
+    /** Device is past the initial inactive period, and waiting for the next idle period. */
+    private static final int STATE_IDLE_PENDING = 2;
+    /** Device is in the idle state, trying to stay asleep as much as possible. */
+    private static final int STATE_IDLE = 3;
+    private static String stateToString(int state) {
+        switch (state) {
+            case STATE_ACTIVE: return "ACTIVE";
+            case STATE_INACTIVE: return "INACTIVE";
+            case STATE_IDLE_PENDING: return "IDLE_PENDING";
+            case STATE_IDLE: return "IDLE";
+            default: return Integer.toString(state);
+        }
+    }
+
+    private int mState;
+
+    private long mNextAlarmTime;
+    private long mNextIdlePendingDelay;
+    private long mNextIdleDelay;
+
+    private final Binder mBinder = new Binder() {
+        @Override protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
+            DeviceIdleController.this.dump(fd, pw, args);
+        }
+    };
+
+    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
+        @Override public void onReceive(Context context, Intent intent) {
+            if (Intent.ACTION_BATTERY_CHANGED.equals(intent.getAction())) {
+                int plugged = intent.getIntExtra("plugged", 0);
+                updateChargingLocked(plugged != 0);
+            } else if (ACTION_STEP_IDLE_STATE.equals(intent.getAction())) {
+                synchronized (DeviceIdleController.this) {
+                    stepIdleStateLocked();
+                }
+            }
+        }
+    };
+
+    private final DisplayManager.DisplayListener mDisplayListener
+            = new DisplayManager.DisplayListener() {
+        @Override public void onDisplayAdded(int displayId) {
+        }
+
+        @Override public void onDisplayRemoved(int displayId) {
+        }
+
+        @Override public void onDisplayChanged(int displayId) {
+            if (displayId == Display.DEFAULT_DISPLAY) {
+                synchronized (DeviceIdleController.this) {
+                    updateDisplayLocked();
+                }
+            }
+        }
+    };
+
+    private final TriggerEventListener mSigMotionListener = new TriggerEventListener() {
+        @Override public void onTrigger(TriggerEvent event) {
+            synchronized (DeviceIdleController.this) {
+                significantMotionLocked();
+            }
+        }
+    };
+
+    public DeviceIdleController(Context context) {
+        super(context);
+    }
+
+    @Override
+    public void onStart() {
+        synchronized (this) {
+            mAlarmManager = (AlarmManager) getContext().getSystemService(Context.ALARM_SERVICE);
+            mBatteryStats = BatteryStatsService.getService();
+            mNetworkPolicyManager = INetworkPolicyManager.Stub.asInterface(
+                                ServiceManager.getService(Context.NETWORK_POLICY_SERVICE));
+            mDisplayManager = (DisplayManager) getContext().getSystemService(
+                    Context.DISPLAY_SERVICE);
+            mSensorManager = (SensorManager) getContext().getSystemService(Context.SENSOR_SERVICE);
+            mSigMotionSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION);
+
+            Intent intent = new Intent(ACTION_STEP_IDLE_STATE)
+                    .setPackage("android")
+                    .setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
+            mAlarmIntent = PendingIntent.getBroadcast(getContext(), 0, intent, 0);
+
+            IntentFilter filter = new IntentFilter();
+            filter.addAction(Intent.ACTION_BATTERY_CHANGED);
+            filter.addAction(ACTION_STEP_IDLE_STATE);
+            getContext().registerReceiver(mReceiver, filter);
+
+            mDisplayManager.registerDisplayListener(mDisplayListener, null);
+
+            mScreenOn = true;
+            // Start out assuming we are charging.  If we aren't, we will at least get
+            // a battery update the next time the level drops.
+            mCharging = true;
+            mState = STATE_ACTIVE;
+            updateDisplayLocked();
+        }
+
+        publishBinderService("deviceidle", mBinder);
+    }
+
+    void updateDisplayLocked() {
+        mCurDisplay = mDisplayManager.getDisplay(Display.DEFAULT_DISPLAY);
+        // We consider any situation where the display is showing something to be it on,
+        // because if there is anything shown we are going to be updating it at some
+        // frequency so can't be allowed to go into deep sleeps.
+        boolean screenOn = mCurDisplay.getState() != Display.STATE_OFF;;
+        if (!screenOn && mScreenOn) {
+            mScreenOn = false;
+            becomeInactiveIfAppropriateLocked();
+        } else if (screenOn) {
+            mScreenOn = true;
+            becomeActiveLocked();
+        }
+    }
+
+    void updateChargingLocked(boolean charging) {
+        if (!charging && mCharging) {
+            mCharging = false;
+            becomeInactiveIfAppropriateLocked();
+        } else if (charging) {
+            mCharging = charging;
+            becomeActiveLocked();
+        }
+    }
+
+    void becomeActiveLocked() {
+        if (mState != STATE_ACTIVE) {
+            try {
+                mNetworkPolicyManager.setDeviceIdleMode(false);
+                mBatteryStats.noteDeviceIdleMode(false, true, false);
+            } catch (RemoteException e) {
+            }
+            mState = STATE_ACTIVE;
+            mNextIdlePendingDelay = 0;
+            mNextIdleDelay = 0;
+            cancelAlarmLocked();
+            stopMonitoringSignificantMotion();
+        }
+    }
+
+    void becomeInactiveIfAppropriateLocked() {
+        if (!mScreenOn && !mCharging && mState == STATE_ACTIVE) {
+            // Screen has turned off; we are now going to become inactive and start
+            // waiting to see if we will ultimately go idle.
+            mState = STATE_INACTIVE;
+            scheduleAlarmLocked(DEFAULT_INACTIVE_TIMEOUT, false);
+        }
+    }
+
+    void stepIdleStateLocked() {
+        switch (mState) {
+            case STATE_INACTIVE:
+                // We have now been inactive long enough, it is time to start looking
+                // for significant motion and sleep some more while doing so.
+                startMonitoringSignificantMotion();
+                scheduleAlarmLocked(DEFAULT_IDLE_AFTER_INACTIVE_TIMEOUT, false);
+                // Reset the upcoming idle delays.
+                mNextIdlePendingDelay = DEFAULT_IDLE_PENDING_TIMEOUT;
+                mNextIdleDelay = DEFAULT_IDLE_TIMEOUT;
+                mState = STATE_IDLE_PENDING;
+                break;
+            case STATE_IDLE_PENDING:
+                // We have been waiting to become idle, and now it is time!  This is the
+                // only case where we want to use a wakeup alarm, because we do want to
+                // drag the device out of its sleep state in this case to do the next
+                // scheduled work.
+                scheduleAlarmLocked(mNextIdleDelay, true);
+                mNextIdleDelay = (long)(mNextIdleDelay*DEFAULT_IDLE_FACTOR);
+                if (mNextIdleDelay > DEFAULT_MAX_IDLE_TIMEOUT) {
+                    mNextIdleDelay = DEFAULT_MAX_IDLE_TIMEOUT;
+                }
+                mState = STATE_IDLE;
+                try {
+                    mNetworkPolicyManager.setDeviceIdleMode(true);
+                    mBatteryStats.noteDeviceIdleMode(true, false, false);
+                } catch (RemoteException e) {
+                }
+                break;
+            case STATE_IDLE:
+                // We have been idling long enough, now it is time to do some work.
+                scheduleAlarmLocked(mNextIdlePendingDelay, false);
+                mNextIdlePendingDelay = (long)(mNextIdlePendingDelay*DEFAULT_IDLE_PENDING_FACTOR);
+                if (mNextIdlePendingDelay > DEFAULT_MAX_IDLE_PENDING_TIMEOUT) {
+                    mNextIdlePendingDelay = DEFAULT_MAX_IDLE_PENDING_TIMEOUT;
+                }
+                mState = STATE_IDLE_PENDING;
+                try {
+                    mNetworkPolicyManager.setDeviceIdleMode(false);
+                    mBatteryStats.noteDeviceIdleMode(false, false, false);
+                } catch (RemoteException e) {
+                }
+                break;
+        }
+    }
+
+    void significantMotionLocked() {
+        // When the sensor goes off, its trigger is automatically removed.
+        mSigMotionActive = false;
+        // The device is not yet active, so we want to go back to the pending idle
+        // state to wait again for no motion.  Note that we only monitor for significant
+        // motion after moving out of the inactive state, so no need to worry about that.
+        if (mState != STATE_ACTIVE) {
+            mState = STATE_INACTIVE;
+            try {
+                mNetworkPolicyManager.setDeviceIdleMode(false);
+                mBatteryStats.noteDeviceIdleMode(false, false, true);
+            } catch (RemoteException e) {
+            }
+            stepIdleStateLocked();
+        }
+    }
+
+    void startMonitoringSignificantMotion() {
+        if (mSigMotionSensor != null && !mSigMotionActive) {
+            mSensorManager.requestTriggerSensor(mSigMotionListener, mSigMotionSensor);
+            mSigMotionActive = true;
+        }
+    }
+
+    void stopMonitoringSignificantMotion() {
+        if (mSigMotionActive) {
+            mSensorManager.cancelTriggerSensor(mSigMotionListener, mSigMotionSensor);
+            mSigMotionActive = false;
+        }
+    }
+
+    void cancelAlarmLocked() {
+        if (mNextAlarmTime != 0) {
+            mNextAlarmTime = 0;
+            mAlarmManager.cancel(mAlarmIntent);
+        }
+    }
+
+    void scheduleAlarmLocked(long delay, boolean wakeup) {
+        if (mSigMotionSensor == null) {
+            // If there is no significant motion sensor on this device, then we won't schedule
+            // alarms, because we can't determine if the device is not moving.  This effectively
+            // turns off normal exeuction of device idling, although it is still possible to
+            // manually poke it by pretending like the alarm is going off.
+            return;
+        }
+        mNextAlarmTime = SystemClock.elapsedRealtime() + delay;
+        mAlarmManager.set(wakeup ? AlarmManager.ELAPSED_REALTIME_WAKEUP
+                : AlarmManager.ELAPSED_REALTIME, mNextAlarmTime, mAlarmIntent);
+    }
+
+    private void dumpHelp(PrintWriter pw) {
+        pw.println("Device idle controller (deviceidle) dump options:");
+        pw.println("  [-h] [CMD]");
+        pw.println("  -h: print this help text.");
+        pw.println("Commands:");
+        pw.println("  step");
+        pw.println("    Immediately step to next state, without waiting for alarm.");
+    }
+
+    void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
+        if (getContext().checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
+                != PackageManager.PERMISSION_GRANTED) {
+            pw.println("Permission Denial: can't dump DeviceIdleController from from pid="
+                    + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid()
+                    + " without permission " + android.Manifest.permission.DUMP);
+            return;
+        }
+
+        if (args != null) {
+            for (int i=0; i<args.length; i++) {
+                String arg = args[i];
+                if ("-h".equals(arg)) {
+                    dumpHelp(pw);
+                    return;
+                } else if ("step".equals(arg)) {
+                    synchronized (this) {
+                        stepIdleStateLocked();
+                        pw.print("Stepped to: "); pw.println(stateToString(mState));
+                    }
+                    return;
+                } else if (arg.length() > 0 && arg.charAt(0) == '-'){
+                    pw.println("Unknown option: " + arg);
+                    dumpHelp(pw);
+                    return;
+                } else {
+                    pw.println("Unknown command: " + arg);
+                    dumpHelp(pw);
+                    return;
+                }
+            }
+        }
+
+        pw.print("  mSigMotionSensor="); pw.println(mSigMotionSensor);
+        pw.print("  mCurDisplay="); pw.println(mCurDisplay);
+        pw.print("  mScreenOn="); pw.println(mScreenOn);
+        pw.print("  mCharging="); pw.println(mCharging);
+        pw.print("  mSigMotionActive="); pw.println(mSigMotionActive);
+        pw.print("  mState="); pw.println(stateToString(mState));
+        if (mNextAlarmTime != 0) {
+            pw.print("  mNextAlarmTime=");
+            TimeUtils.formatDuration(mNextAlarmTime, SystemClock.elapsedRealtime(), pw);
+            pw.println();
+        }
+        if (mNextIdlePendingDelay != 0) {
+            pw.print("  mNextIdlePendingDelay=");
+            TimeUtils.formatDuration(mNextIdlePendingDelay, pw);
+            pw.println();
+        }
+        if (mNextIdleDelay != 0) {
+            pw.print("  mNextIdleDelay=");
+            TimeUtils.formatDuration(mNextIdleDelay, pw);
+            pw.println();
+        }
+    }
+}
diff --git a/services/core/java/com/android/server/am/ActivityManagerService.java b/services/core/java/com/android/server/am/ActivityManagerService.java
index dcee96a..7f4ccb7 100644
--- a/services/core/java/com/android/server/am/ActivityManagerService.java
+++ b/services/core/java/com/android/server/am/ActivityManagerService.java
@@ -15798,6 +15798,7 @@ public final class ActivityManagerService extends ActivityManagerNative
                                         if (userId == UserHandle.USER_OWNER) {
                                             mTaskPersister.removeFromPackageCache(ssp);
                                         }
+                                        mBatteryStatsService.notePackageUninstalled(ssp);
                                     }
                                 } else {
                                     removeTasksByRemovedPackageComponentsLocked(ssp, userId);
@@ -15824,6 +15825,13 @@ public final class ActivityManagerService extends ActivityManagerNative
                         if (userId == UserHandle.USER_OWNER) {
                             mTaskPersister.addOtherDeviceTasksToRecentsLocked(ssp);
                         }
+                        try {
+                            ApplicationInfo ai = AppGlobals.getPackageManager().
+                                    getApplicationInfo(ssp, 0, 0);
+                            mBatteryStatsService.notePackageInstalled(ssp,
+                                    ai != null ? ai.versionCode : 0);
+                        } catch (RemoteException e) {
+                        }
                     }
                     break;
                 case Intent.ACTION_TIMEZONE_CHANGED:
diff --git a/services/core/java/com/android/server/am/BatteryStatsService.java b/services/core/java/com/android/server/am/BatteryStatsService.java
index 6eacfa9..197b51d 100644
--- a/services/core/java/com/android/server/am/BatteryStatsService.java
+++ b/services/core/java/com/android/server/am/BatteryStatsService.java
@@ -86,7 +86,7 @@ public final class BatteryStatsService extends IBatteryStats.Stub
     public void initPowerManagement() {
         mPowerManagerInternal = LocalServices.getService(PowerManagerInternal.class);
         mPowerManagerInternal.registerLowPowerModeObserver(this);
-        mStats.noteLowPowerMode(mPowerManagerInternal.getLowPowerModeEnabled());
+        mStats.notePowerSaveMode(mPowerManagerInternal.getLowPowerModeEnabled());
         (new WakeupReasonThread()).start();
     }
 
@@ -109,7 +109,7 @@ public final class BatteryStatsService extends IBatteryStats.Stub
     @Override
     public void onLowPowerModeChanged(boolean enabled) {
         synchronized (mStats) {
-            mStats.noteLowPowerMode(enabled);
+            mStats.notePowerSaveMode(enabled);
         }
     }
 
@@ -686,6 +686,28 @@ public final class BatteryStatsService extends IBatteryStats.Stub
         }
     }
 
+    @Override
+    public void noteDeviceIdleMode(boolean enabled, boolean fromActive, boolean fromMotion) {
+        enforceCallingPermission();
+        synchronized (mStats) {
+            mStats.noteDeviceIdleModeLocked(enabled, fromActive, fromMotion);
+        }
+    }
+
+    public void notePackageInstalled(String pkgName, int versionCode) {
+        enforceCallingPermission();
+        synchronized (mStats) {
+            mStats.notePackageInstalledLocked(pkgName, versionCode);
+        }
+    }
+
+    public void notePackageUninstalled(String pkgName) {
+        enforceCallingPermission();
+        synchronized (mStats) {
+            mStats.notePackageUninstalledLocked(pkgName);
+        }
+    }
+
     public boolean isOnBattery() {
         return mStats.isOnBattery();
     }
diff --git a/services/core/java/com/android/server/job/JobSchedulerService.java b/services/core/java/com/android/server/job/JobSchedulerService.java
index 83d6986..fe1260d 100644
--- a/services/core/java/com/android/server/job/JobSchedulerService.java
+++ b/services/core/java/com/android/server/job/JobSchedulerService.java
@@ -22,6 +22,7 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
+import android.app.ActivityManager;
 import android.app.AppGlobals;
 import android.app.job.JobInfo;
 import android.app.job.JobScheduler;
@@ -72,7 +73,8 @@ public class JobSchedulerService extends com.android.server.SystemService
         implements StateChangedListener, JobCompletedListener {
     static final boolean DEBUG = false;
     /** The number of concurrent jobs we run at one time. */
-    private static final int MAX_JOB_CONTEXTS_COUNT = 3;
+    private static final int MAX_JOB_CONTEXTS_COUNT
+            = ActivityManager.isLowRamDeviceStatic() ? 1 : 3;
     static final String TAG = "JobSchedulerService";
     /** Master list of jobs. */
     final JobStore mJobs;
diff --git a/services/core/java/com/android/server/net/NetworkPolicyManagerService.java b/services/core/java/com/android/server/net/NetworkPolicyManagerService.java
index cc0fcf5..a69a95f 100644
--- a/services/core/java/com/android/server/net/NetworkPolicyManagerService.java
+++ b/services/core/java/com/android/server/net/NetworkPolicyManagerService.java
@@ -243,9 +243,11 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
 
     final Object mRulesLock = new Object();
 
+    volatile boolean mSystemReady;
     volatile boolean mScreenOn;
     volatile boolean mRestrictBackground;
     volatile boolean mRestrictPower;
+    volatile boolean mDeviceIdleMode;
 
     private final boolean mSuppressDefaultPolicy;
 
@@ -367,11 +369,12 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
                 }
             });
             mRestrictPower = mPowerManagerInternal.getLowPowerModeEnabled();
+            mSystemReady = true;
 
             // read policy from disk
             readPolicyLocked();
 
-            if (mRestrictBackground || mRestrictPower) {
+            if (mRestrictBackground || mRestrictPower || mDeviceIdleMode) {
                 updateRulesForGlobalChangeLocked(true);
                 updateNotificationsLocked();
             }
@@ -1031,7 +1034,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
         // will not have a bandwidth limit.  Also only do this if restrict
         // background data use is *not* enabled, since that takes precendence
         // use over those networks can have a cost associated with it).
-        final boolean powerSave = mRestrictPower && !mRestrictBackground;
+        final boolean powerSave = (mRestrictPower || mDeviceIdleMode) && !mRestrictBackground;
 
         // First, generate identities of all connected networks so we can
         // quickly compare them against all defined policies below.
@@ -1696,6 +1699,20 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
         }
     }
 
+    @Override
+    public void setDeviceIdleMode(boolean enabled) {
+        mContext.enforceCallingOrSelfPermission(MANAGE_NETWORK_POLICY, TAG);
+
+        synchronized (mRulesLock) {
+            if (mDeviceIdleMode != enabled) {
+                mDeviceIdleMode = enabled;
+                if (mSystemReady) {
+                    updateRulesForGlobalChangeLocked(true);
+                }
+            }
+        }
+    }
+
     private NetworkPolicy findPolicyForNetworkLocked(NetworkIdentity ident) {
         for (int i = mNetworkPolicy.size()-1; i >= 0; i--) {
             NetworkPolicy policy = mNetworkPolicy.valueAt(i);
@@ -1801,8 +1818,10 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
                 return;
             }
 
+            fout.print("System ready: "); fout.println(mSystemReady);
             fout.print("Restrict background: "); fout.println(mRestrictBackground);
             fout.print("Restrict power: "); fout.println(mRestrictPower);
+            fout.print("Device idle: "); fout.println(mDeviceIdleMode);
             fout.print("Current foreground state: "); fout.println(mCurForegroundState);
             fout.println("Network policies:");
             fout.increaseIndent();
@@ -1952,8 +1971,8 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
     }
 
     /**
-     * Update rules that might be changed by {@link #mRestrictBackground}
-     * or {@link #mRestrictPower} value.
+     * Update rules that might be changed by {@link #mRestrictBackground},
+     * {@link #mRestrictPower}, or {@link #mDeviceIdleMode} value.
      */
     void updateRulesForGlobalChangeLocked(boolean restrictedNetworksChanged) {
         final PackageManager pm = mContext.getPackageManager();
@@ -1962,7 +1981,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
         // If we are in restrict power mode, we allow all important apps
         // to have data access.  Otherwise, we restrict data access to only
         // the top apps.
-        mCurForegroundState = (!mRestrictBackground && mRestrictPower)
+        mCurForegroundState = (!mRestrictBackground && (mRestrictPower || mDeviceIdleMode))
                 ? ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND
                 : ActivityManager.PROCESS_STATE_TOP;
 
@@ -2015,7 +2034,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
                 // uid in background, and global background disabled
                 uidRules = RULE_REJECT_METERED;
             }
-        } else if (mRestrictPower) {
+        } else if (mRestrictPower || mDeviceIdleMode) {
             final boolean whitelisted = mPowerSaveWhitelistAppIds.get(UserHandle.getAppId(uid));
             if (!whitelisted && !uidForeground
                     && (uidPolicy & POLICY_ALLOW_BACKGROUND_BATTERY_SAVE) == 0) {
diff --git a/services/java/com/android/server/SystemServer.java b/services/java/com/android/server/SystemServer.java
index a0c7f86..ed55c56 100644
--- a/services/java/com/android/server/SystemServer.java
+++ b/services/java/com/android/server/SystemServer.java
@@ -960,6 +960,7 @@ public final class SystemServer {
 
         if (!disableNonCoreServices) {
             mSystemServiceManager.startService(MediaProjectionManagerService.class);
+            mSystemServiceManager.startService(DeviceIdleController.class);
         }
 
         // Before things start rolling, be sure we have decided whether