diff --git a/services/core/java/com/android/server/AlarmManagerService.java b/services/core/java/com/android/server/AlarmManagerService.java
index d1cf025..cab6ecf 100644
--- a/services/core/java/com/android/server/AlarmManagerService.java
+++ b/services/core/java/com/android/server/AlarmManagerService.java
@@ -46,6 +46,7 @@
 import android.os.PowerManager;
 import android.os.Process;
 import android.os.RemoteException;
+import android.os.ServiceManager;
 import android.os.SystemClock;
 import android.os.SystemProperties;
 import android.os.UserHandle;
@@ -54,6 +55,7 @@
 import android.text.TextUtils;
 import android.text.format.DateFormat;
 import android.util.ArrayMap;
+import android.util.ArraySet;
 import android.util.KeyValueListParser;
 import android.util.Log;
 import android.util.Slog;
@@ -85,6 +87,8 @@
 import static android.app.AlarmManager.ELAPSED_REALTIME;
 
 import com.android.internal.annotations.GuardedBy;
+import com.android.internal.app.IAppOpsCallback;
+import com.android.internal.app.IAppOpsService;
 import com.android.internal.util.DumpUtils;
 import com.android.internal.util.LocalLog;
 
@@ -106,6 +110,7 @@
     static final boolean DEBUG_ALARM_CLOCK = localLOGV || false;
     static final boolean DEBUG_LISTENER_CALLBACK = localLOGV || false;
     static final boolean DEBUG_WAKELOCK = localLOGV || false;
+    static final boolean DEBUG_BG_LIMIT = localLOGV || false;
     static final boolean RECORD_ALARMS_IN_HISTORY = true;
     static final boolean RECORD_DEVICE_IDLE_ALARMS = false;
     static final int ALARM_EVENT = 1;
@@ -114,7 +119,7 @@
     private final Intent mBackgroundIntent
             = new Intent().addFlags(Intent.FLAG_FROM_BACKGROUND);
     static final IncreasingTimeOrder sIncreasingTimeOrder = new IncreasingTimeOrder();
-    
+
     static final boolean WAKEUP_STATS = false;
 
     private static final Intent NEXT_ALARM_CLOCK_CHANGED_INTENT =
@@ -125,10 +130,15 @@
     final LocalLog mLog = new LocalLog(TAG);
 
     AppOpsManager mAppOps;
+    IAppOpsService mAppOpsService;
     DeviceIdleController.LocalService mLocalDeviceIdleController;
 
     final Object mLock = new Object();
 
+    ArraySet<String> mForcedAppStandbyPackages = new ArraySet<>();
+    SparseBooleanArray mForegroundUids = new SparseBooleanArray();
+    // List of alarms per uid deferred due to user applied background restrictions on the source app
+    SparseArray<ArrayList<Alarm>> mPendingBackgroundAlarms = new SparseArray<>();
     long mNativeData;
     private long mNextWakeup;
     private long mNextNonWakeup;
@@ -225,6 +235,7 @@
         private static final String KEY_ALLOW_WHILE_IDLE_WHITELIST_DURATION
                 = "allow_while_idle_whitelist_duration";
         private static final String KEY_LISTENER_TIMEOUT = "listener_timeout";
+        private static final String KEY_BG_RESTRICTIONS_ENABLED = "limit_bg_alarms_enabled";
 
         private static final long DEFAULT_MIN_FUTURITY = 5 * 1000;
         private static final long DEFAULT_MIN_INTERVAL = 60 * 1000;
@@ -234,6 +245,8 @@
 
         private static final long DEFAULT_LISTENER_TIMEOUT = 5 * 1000;
 
+        private static final boolean DEFAULT_BACKGROUND_RESTRICTIONS_ENABLED = false;
+
         // Minimum futurity of a new alarm
         public long MIN_FUTURITY = DEFAULT_MIN_FUTURITY;
 
@@ -253,6 +266,8 @@
         // Direct alarm listener callback timeout
         public long LISTENER_TIMEOUT = DEFAULT_LISTENER_TIMEOUT;
 
+        public boolean BACKGROUND_ALARMS_BLOCKED = DEFAULT_BACKGROUND_RESTRICTIONS_ENABLED;
+
         private ContentResolver mResolver;
         private final KeyValueListParser mParser = new KeyValueListParser(',');
         private long mLastAllowWhileIdleWhitelistDuration = -1;
@@ -311,6 +326,21 @@
                         DEFAULT_ALLOW_WHILE_IDLE_WHITELIST_DURATION);
                 LISTENER_TIMEOUT = mParser.getLong(KEY_LISTENER_TIMEOUT,
                         DEFAULT_LISTENER_TIMEOUT);
+                BACKGROUND_ALARMS_BLOCKED = mParser.getBoolean(KEY_BG_RESTRICTIONS_ENABLED,
+                        DEFAULT_BACKGROUND_RESTRICTIONS_ENABLED);
+                if (!BACKGROUND_ALARMS_BLOCKED) {
+                    // TODO: remove this code and constant when feature is turned on
+                    // deliver all blocked alarms
+                    final ArrayList<Alarm> allBlockedAlarms = new ArrayList<>();
+                    for (int i = mPendingBackgroundAlarms.size() - 1; i >=0; i--) {
+                        allBlockedAlarms.addAll(mPendingBackgroundAlarms.valueAt(i));
+                    }
+                    mPendingBackgroundAlarms = new SparseArray<>();
+                    deliverPendingBackgroundAlarmsLocked(allBlockedAlarms,
+                            SystemClock.elapsedRealtime());
+                } else if (DEBUG_BG_LIMIT) {
+                    Slog.d(TAG, "Background limiting enabled");
+                }
 
                 updateAllowWhileIdleMinTimeLocked();
                 updateAllowWhileIdleWhitelistDurationLocked();
@@ -705,7 +735,7 @@
     static final BatchTimeOrder sBatchOrder = new BatchTimeOrder();
     final ArrayList<Batch> mAlarmBatches = new ArrayList<>();
 
-    // set to null if in idle mode; while in this mode, any alarms we don't want
+    // set to non-null if in idle mode; while in this mode, any alarms we don't want
     // to run during this time are placed in mPendingWhileIdleAlarms
     Alarm mPendingIdleUntil = null;
     Alarm mNextWakeFromIdle = null;
@@ -814,6 +844,108 @@
         setImplLocked(a, true, doValidate);
     }
 
+    /**
+     * Sends alarms that were blocked due to user applied background restrictions - either because
+     * the user lifted those or the uid came to foreground.
+     *
+     * @param uid uid to filter on
+     * @param packageName package to filter on, or null for all packages in uid
+     */
+    void sendPendingBackgroundAlarmsLocked(int uid, String packageName) {
+        final ArrayList<Alarm> alarmsForUid = mPendingBackgroundAlarms.get(uid);
+        if (alarmsForUid == null || alarmsForUid.size() == 0) {
+            return;
+        }
+        final ArrayList<Alarm> alarmsToDeliver;
+        if (packageName != null) {
+            if (DEBUG_BG_LIMIT) {
+                Slog.d(TAG, "Sending blocked alarms for uid " + uid + ", package " + packageName);
+            }
+            alarmsToDeliver = new ArrayList<>();
+            for (int i = alarmsForUid.size() - 1; i >= 0; i--) {
+                final Alarm a = alarmsForUid.get(i);
+                if (a.matches(packageName)) {
+                    alarmsToDeliver.add(alarmsForUid.remove(i));
+                }
+            }
+            if (alarmsForUid.size() == 0) {
+                mPendingBackgroundAlarms.remove(uid);
+            }
+        } else {
+            if (DEBUG_BG_LIMIT) {
+                Slog.d(TAG, "Sending blocked alarms for uid " + uid);
+            }
+            alarmsToDeliver = alarmsForUid;
+            mPendingBackgroundAlarms.remove(uid);
+        }
+        deliverPendingBackgroundAlarmsLocked(alarmsToDeliver, SystemClock.elapsedRealtime());
+    }
+
+    void sendPendingBackgroundAlarmsForAppIdLocked(int appId) {
+        final ArrayList<Alarm> alarmsToDeliver = new ArrayList<>();
+        for (int i = mPendingBackgroundAlarms.size() - 1; i >= 0; i--) {
+            final int uid = mPendingBackgroundAlarms.keyAt(i);
+            final ArrayList<Alarm> alarmsForUid = mPendingBackgroundAlarms.valueAt(i);
+            if (UserHandle.getAppId(uid) == appId) {
+                alarmsToDeliver.addAll(alarmsForUid);
+                mPendingBackgroundAlarms.removeAt(i);
+            }
+        }
+        deliverPendingBackgroundAlarmsLocked(alarmsToDeliver, SystemClock.elapsedRealtime());
+    }
+
+    private void deliverPendingBackgroundAlarmsLocked(ArrayList<Alarm> alarms, long nowELAPSED) {
+        final int N = alarms.size();
+        boolean hasWakeup = false;
+        for (int i = 0; i < N; i++) {
+            final Alarm alarm = alarms.get(i);
+            if (alarm.wakeup) {
+                hasWakeup = true;
+            }
+            alarm.count = 1;
+            // Recurring alarms may have passed several alarm intervals while the
+            // alarm was kept pending. Send the appropriate trigger count.
+            if (alarm.repeatInterval > 0) {
+                alarm.count += (nowELAPSED - alarm.whenElapsed) / alarm.repeatInterval;
+                // Also schedule its next recurrence
+                final long delta = alarm.count * alarm.repeatInterval;
+                final long nextElapsed = alarm.whenElapsed + delta;
+                setImplLocked(alarm.type, alarm.when + delta, nextElapsed, alarm.windowLength,
+                        maxTriggerTime(nowELAPSED, nextElapsed, alarm.repeatInterval),
+                        alarm.repeatInterval, alarm.operation, null, null, alarm.flags, true,
+                        alarm.workSource, alarm.alarmClock, alarm.uid, alarm.packageName);
+                // Kernel alarms will be rescheduled as needed in setImplLocked
+            }
+        }
+        if (!hasWakeup && checkAllowNonWakeupDelayLocked(nowELAPSED)) {
+            // No need to wakeup for non wakeup alarms
+            if (mPendingNonWakeupAlarms.size() == 0) {
+                mStartCurrentDelayTime = nowELAPSED;
+                mNextNonWakeupDeliveryTime = nowELAPSED
+                        + ((currentNonWakeupFuzzLocked(nowELAPSED)*3)/2);
+            }
+            mPendingNonWakeupAlarms.addAll(alarms);
+            mNumDelayedAlarms += alarms.size();
+        } else {
+            if (DEBUG_BG_LIMIT) {
+                Slog.d(TAG, "Waking up to deliver pending blocked alarms");
+            }
+            // Since we are waking up, also deliver any pending non wakeup alarms we have.
+            if (mPendingNonWakeupAlarms.size() > 0) {
+                alarms.addAll(mPendingNonWakeupAlarms);
+                final long thisDelayTime = nowELAPSED - mStartCurrentDelayTime;
+                mTotalDelayTime += thisDelayTime;
+                if (mMaxDelayTime < thisDelayTime) {
+                    mMaxDelayTime = thisDelayTime;
+                }
+                mPendingNonWakeupAlarms.clear();
+            }
+            calculateDeliveryPriorities(alarms);
+            Collections.sort(alarms, mAlarmDispatchComparator);
+            deliverAlarmsLocked(alarms, nowELAPSED);
+        }
+    }
+
     void restorePendingWhileIdleAlarmsLocked() {
         if (RECORD_DEVICE_IDLE_ALARMS) {
             IdleDispatchEntry ent = new IdleDispatchEntry();
@@ -1032,11 +1164,14 @@
 
         try {
             ActivityManager.getService().registerUidObserver(new UidObserver(),
-                    ActivityManager.UID_OBSERVER_IDLE, ActivityManager.PROCESS_STATE_UNKNOWN, null);
+                    ActivityManager.UID_OBSERVER_GONE | ActivityManager.UID_OBSERVER_IDLE
+                            | ActivityManager.UID_OBSERVER_ACTIVE,
+                    ActivityManager.PROCESS_STATE_UNKNOWN, null);
         } catch (RemoteException e) {
             // ignored; both services live in system_server
         }
-
+        mAppOpsService = IAppOpsService.Stub.asInterface(
+                ServiceManager.getService(Context.APP_OPS_SERVICE));
         publishBinderService(Context.ALARM_SERVICE, mService);
         publishLocalService(LocalService.class, new LocalService());
     }
@@ -1048,6 +1183,13 @@
             mAppOps = (AppOpsManager) getContext().getSystemService(Context.APP_OPS_SERVICE);
             mLocalDeviceIdleController
                     = LocalServices.getService(DeviceIdleController.LocalService.class);
+            try {
+                mAppOpsService.startWatchingMode(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, null,
+                        new AppOpsWatcher());
+            } catch (RemoteException rexc) {
+                // Shouldn't happen as they are in the same process.
+                Slog.e(TAG, "AppOps service not reachable", rexc);
+            }
         }
     }
 
@@ -1461,6 +1603,12 @@
             mConstants.dump(pw);
             pw.println();
 
+            pw.print("  Foreground uids: [");
+            for (int i = 0; i < mForegroundUids.size(); i++) {
+                if (mForegroundUids.valueAt(i)) pw.print(mForegroundUids.keyAt(i) + " ");
+            }
+            pw.println("]");
+            pw.println("  Forced app standby packages: " + mForcedAppStandbyPackages);
             final long nowRTC = System.currentTimeMillis();
             final long nowELAPSED = SystemClock.elapsedRealtime();
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
@@ -1533,6 +1681,19 @@
                     dumpAlarmList(pw, b.alarms, "    ", nowELAPSED, nowRTC, sdf);
                 }
             }
+            pw.println();
+            pw.println("  Pending user blocked background alarms: ");
+            boolean blocked = false;
+            for (int i = 0; i < mPendingBackgroundAlarms.size(); i++) {
+                final ArrayList<Alarm> blockedAlarms = mPendingBackgroundAlarms.valueAt(i);
+                if (blockedAlarms != null && blockedAlarms.size() > 0) {
+                    blocked = true;
+                    dumpAlarmList(pw, blockedAlarms, "    ", nowELAPSED, nowRTC, sdf);
+                }
+            }
+            if (!blocked) {
+                pw.println("    none");
+            }
             if (mPendingIdleUntil != null || mPendingWhileIdleAlarms.size() > 0) {
                 pw.println();
                 pw.println("    Idle mode state:");
@@ -1799,6 +1960,22 @@
 
     void setDeviceIdleUserWhitelistImpl(int[] appids) {
         synchronized (mLock) {
+            // appids are sorted, just send pending alarms for any new appids added to the whitelist
+            int i = 0, j = 0;
+            while (i < appids.length) {
+                while (j < mDeviceIdleUserWhitelist.length
+                        && mDeviceIdleUserWhitelist[j] < appids[i]) {
+                    j++;
+                }
+                if (j < mDeviceIdleUserWhitelist.length
+                        && appids[i] != mDeviceIdleUserWhitelist[j]) {
+                    if (DEBUG_BG_LIMIT) {
+                        Slog.d(TAG, "Sending blocked alarms for whitelisted appid " + appids[j]);
+                    }
+                    sendPendingBackgroundAlarmsForAppIdLocked(appids[j]);
+                }
+                i++;
+            }
             mDeviceIdleUserWhitelist = appids;
         }
     }
@@ -1979,7 +2156,18 @@
                 mPendingWhileIdleAlarms.remove(i);
             }
         }
-
+        for (int i = mPendingBackgroundAlarms.size() - 1; i >= 0; i--) {
+            final ArrayList<Alarm> alarmsForUid = mPendingBackgroundAlarms.valueAt(i);
+            for (int j = alarmsForUid.size() - 1; j >= 0; j--) {
+                if (alarmsForUid.get(j).matches(operation, directReceiver)) {
+                    // Don't set didRemove, since this doesn't impact the scheduled alarms.
+                    alarmsForUid.remove(j);
+                }
+            }
+            if (alarmsForUid.size() == 0) {
+                mPendingBackgroundAlarms.removeAt(i);
+            }
+        }
         if (didRemove) {
             if (DEBUG_BATCH) {
                 Slog.v(TAG, "remove(operation) changed bounds; rebatching");
@@ -2016,7 +2204,17 @@
                 mPendingWhileIdleAlarms.remove(i);
             }
         }
-
+        for (int i = mPendingBackgroundAlarms.size() - 1; i >= 0; i --) {
+            final ArrayList<Alarm> alarmsForUid = mPendingBackgroundAlarms.valueAt(i);
+            for (int j = alarmsForUid.size() - 1; j >= 0; j--) {
+                if (alarmsForUid.get(j).matches(packageName)) {
+                    alarmsForUid.remove(j);
+                }
+            }
+            if (alarmsForUid.size() == 0) {
+                mPendingBackgroundAlarms.removeAt(i);
+            }
+        }
         if (didRemove) {
             if (DEBUG_BATCH) {
                 Slog.v(TAG, "remove(package) changed bounds; rebatching");
@@ -2043,7 +2241,11 @@
                 mPendingWhileIdleAlarms.remove(i);
             }
         }
-
+        for (int i = mPendingBackgroundAlarms.size() - 1; i >= 0; i--) {
+            if (mPendingBackgroundAlarms.keyAt(i) == uid) {
+                mPendingBackgroundAlarms.removeAt(i);
+            }
+        }
         if (didRemove) {
             if (DEBUG_BATCH) {
                 Slog.v(TAG, "remove(package) changed bounds; rebatching");
@@ -2070,6 +2272,11 @@
                 mPendingWhileIdleAlarms.remove(i);
             }
         }
+        for (int i = mPendingBackgroundAlarms.size() - 1; i >= 0; i--) {
+            if (UserHandle.getUserId(mPendingBackgroundAlarms.keyAt(i)) == userHandle) {
+                mPendingBackgroundAlarms.removeAt(i);
+            }
+        }
         for (int i = mLastAllowWhileIdleDispatch.size() - 1; i >= 0; i--) {
             if (UserHandle.getUserId(mLastAllowWhileIdleDispatch.keyAt(i)) == userHandle) {
                 mLastAllowWhileIdleDispatch.removeAt(i);
@@ -2184,6 +2391,27 @@
         }
     }
 
+    private boolean isBackgroundRestricted(Alarm alarm) {
+        if (!mConstants.BACKGROUND_ALARMS_BLOCKED) {
+            return false;
+        }
+        if (alarm.alarmClock != null) {
+            // Don't block alarm clocks
+            return false;
+        }
+        if (alarm.operation != null
+                && (alarm.operation.isActivity() || alarm.operation.isForegroundService())) {
+            // Don't block starting foreground components
+            return false;
+        }
+        final String sourcePackage =
+                (alarm.operation != null) ? alarm.operation.getCreatorPackage() : alarm.packageName;
+        final int sourceUid = alarm.creatorUid;
+        return mForcedAppStandbyPackages.contains(sourcePackage) && !mForegroundUids.get(sourceUid)
+                && Arrays.binarySearch(mDeviceIdleUserWhitelist, UserHandle.getAppId(sourceUid))
+                < 0;
+    }
+
     private native long init();
     private native void close(long nativeData);
     private native void set(long nativeData, int type, long seconds, long nanoseconds);
@@ -2239,6 +2467,19 @@
                         continue;
                     }
                 }
+                if (isBackgroundRestricted(alarm)) {
+                    // Alarms with FLAG_WAKE_FROM_IDLE or mPendingIdleUntil alarm are not deferred
+                    if (DEBUG_BG_LIMIT) {
+                        Slog.d(TAG, "Deferring alarm " + alarm + " due to user forced app standby");
+                    }
+                    ArrayList<Alarm> alarmsForUid = mPendingBackgroundAlarms.get(alarm.creatorUid);
+                    if (alarmsForUid == null) {
+                        alarmsForUid = new ArrayList<>();
+                        mPendingBackgroundAlarms.put(alarm.creatorUid, alarmsForUid);
+                    }
+                    alarmsForUid.add(alarm);
+                    continue;
+                }
 
                 alarm.count = 1;
                 triggerList.add(alarm);
@@ -2904,21 +3145,29 @@
         }
 
         @Override public void onUidGone(int uid, boolean disabled) {
-            if (disabled) {
-                synchronized (mLock) {
+            synchronized (mLock) {
+                if (disabled) {
                     removeForStoppedLocked(uid);
                 }
+                mForegroundUids.delete(uid);
             }
         }
 
         @Override public void onUidActive(int uid) {
+            synchronized (mLock) {
+                if (!mForegroundUids.get(uid)) {
+                    mForegroundUids.put(uid, true);
+                    sendPendingBackgroundAlarmsLocked(uid, null);
+                }
+            }
         }
 
         @Override public void onUidIdle(int uid, boolean disabled) {
-            if (disabled) {
-                synchronized (mLock) {
+            synchronized (mLock) {
+                if (disabled) {
                     removeForStoppedLocked(uid);
                 }
+                mForegroundUids.delete(uid);
             }
         }
 
@@ -2926,6 +3175,28 @@
         }
     };
 
+    private final class AppOpsWatcher extends IAppOpsCallback.Stub {
+        @Override
+        public void opChanged(int op, int uid, String packageName) throws RemoteException {
+            synchronized (mLock) {
+                final int mode = mAppOpsService.checkOperation(op, uid, packageName);
+                if (DEBUG_BG_LIMIT) {
+                    Slog.d(TAG,
+                            "Appop changed for " + uid + ", " + packageName + " to " + mode);
+                }
+                final boolean changed;
+                if (mode != AppOpsManager.MODE_ALLOWED) {
+                    changed = mForcedAppStandbyPackages.add(packageName);
+                } else {
+                    changed = mForcedAppStandbyPackages.remove(packageName);
+                }
+                if (changed && mode == AppOpsManager.MODE_ALLOWED) {
+                    sendPendingBackgroundAlarmsLocked(uid, packageName);
+                }
+            }
+        }
+    }
+
     private final BroadcastStats getStatsLocked(PendingIntent pi) {
         String pkg = pi.getCreatorPackage();
         int uid = pi.getCreatorUid();