diff --git a/services/core/java/com/android/server/am/ActiveServices.java b/services/core/java/com/android/server/am/ActiveServices.java
index 7f8d944..93cf6ce 100644
--- a/services/core/java/com/android/server/am/ActiveServices.java
+++ b/services/core/java/com/android/server/am/ActiveServices.java
@@ -70,6 +70,7 @@
 
 import android.annotation.NonNull;
 import android.annotation.Nullable;
+import android.annotation.UptimeMillisLong;
 import android.app.ActivityManager;
 import android.app.ActivityManagerInternal;
 import android.app.ActivityThread;
@@ -237,6 +238,12 @@
     private final SparseArray<AppOpCallback> mFgsAppOpCallbacks = new SparseArray<>();
 
     /**
+     * The list of packages with the service restart backoff disabled.
+     */
+    @GuardedBy("mAm")
+    private final ArraySet<String> mRestartBackoffDisabledPackages = new ArraySet<>();
+
+    /**
      * For keeping ActiveForegroundApps retaining state while the screen is off.
      */
     boolean mScreenOn = true;
@@ -3272,25 +3279,32 @@
                 }
             }
 
-            r.nextRestartTime = now + r.restartDelay;
+            if (isServiceRestartBackoffEnabledLocked(r.packageName)) {
+                r.nextRestartTime = now + r.restartDelay;
 
-            // Make sure that we don't end up restarting a bunch of services
-            // all at the same time.
-            boolean repeat;
-            do {
-                repeat = false;
+                // Make sure that we don't end up restarting a bunch of services
+                // all at the same time.
+                boolean repeat;
                 final long restartTimeBetween = mAm.mConstants.SERVICE_MIN_RESTART_TIME_BETWEEN;
-                for (int i=mRestartingServices.size()-1; i>=0; i--) {
-                    ServiceRecord r2 = mRestartingServices.get(i);
-                    if (r2 != r && r.nextRestartTime >= (r2.nextRestartTime-restartTimeBetween)
-                            && r.nextRestartTime < (r2.nextRestartTime+restartTimeBetween)) {
-                        r.nextRestartTime = r2.nextRestartTime + restartTimeBetween;
-                        r.restartDelay = r.nextRestartTime - now;
-                        repeat = true;
-                        break;
+                do {
+                    repeat = false;
+                    for (int i = mRestartingServices.size() - 1; i >= 0; i--) {
+                        final ServiceRecord r2 = mRestartingServices.get(i);
+                        if (r2 != r
+                                && r.nextRestartTime >= (r2.nextRestartTime - restartTimeBetween)
+                                && r.nextRestartTime < (r2.nextRestartTime + restartTimeBetween)) {
+                            r.nextRestartTime = r2.nextRestartTime + restartTimeBetween;
+                            r.restartDelay = r.nextRestartTime - now;
+                            repeat = true;
+                            break;
+                        }
                     }
-                }
-            } while (repeat);
+                } while (repeat);
+            } else {
+                // It's been forced to ignore the restart backoff, fix the delay here.
+                r.restartDelay = mAm.mConstants.SERVICE_RESTART_DURATION;
+                r.nextRestartTime = now + r.restartDelay;
+            }
 
         } else {
             // Persistent processes are immediately restarted, so there is no
@@ -3310,15 +3324,22 @@
 
         cancelForegroundNotificationLocked(r);
 
+        performScheduleRestartLocked(r, "Scheduling", reason, SystemClock.uptimeMillis());
+
+        return true;
+    }
+
+    @VisibleForTesting
+    @GuardedBy("mAm")
+    void performScheduleRestartLocked(ServiceRecord r, @NonNull String scheduling,
+            @NonNull String reason, @UptimeMillisLong long now) {
         mAm.mHandler.removeCallbacks(r.restarter);
         mAm.mHandler.postAtTime(r.restarter, r.nextRestartTime);
-        r.nextRestartTime = SystemClock.uptimeMillis() + r.restartDelay;
-        Slog.w(TAG, "Scheduling restart of crashed service "
+        r.nextRestartTime = now + r.restartDelay;
+        Slog.w(TAG, scheduling + " restart of crashed service "
                 + r.shortInstanceName + " in " + r.restartDelay + "ms for " + reason);
         EventLog.writeEvent(EventLogTags.AM_SCHEDULE_SERVICE_RESTART,
                 r.userId, r.shortInstanceName, r.restartDelay);
-
-        return true;
     }
 
     final void performServiceRestartLocked(ServiceRecord r) {
@@ -3383,6 +3404,52 @@
         }
     }
 
+    /**
+     * Toggle service restart backoff policy, used by {@link ActivityManagerShellCommand}.
+     */
+    @GuardedBy("mAm")
+    void setServiceRestartBackoffEnabledLocked(@NonNull String packageName, boolean enable,
+            @NonNull String reason) {
+        if (!enable) {
+            if (mRestartBackoffDisabledPackages.contains(packageName)) {
+                // Already disabled, do nothing.
+                return;
+            }
+            mRestartBackoffDisabledPackages.add(packageName);
+
+            final long now = SystemClock.uptimeMillis();
+            for (int i = 0, size = mRestartingServices.size(); i < size; i++) {
+                final ServiceRecord r = mRestartingServices.get(i);
+                if (TextUtils.equals(r.packageName, packageName)) {
+                    final long remaining = r.nextRestartTime - now;
+                    if (remaining > mAm.mConstants.SERVICE_RESTART_DURATION) {
+                        r.restartDelay = mAm.mConstants.SERVICE_RESTART_DURATION;
+                        r.nextRestartTime = now + r.restartDelay;
+                        performScheduleRestartLocked(r, "Rescheduling", reason, now);
+                    }
+                }
+            }
+        } else {
+            removeServiceRestartBackoffEnabledLocked(packageName);
+            // For the simplicity, we are not going to reschedule its pending restarts
+            // when we turn the backoff policy back on.
+        }
+    }
+
+    @GuardedBy("mAm")
+    private void removeServiceRestartBackoffEnabledLocked(@NonNull String packageName) {
+        mRestartBackoffDisabledPackages.remove(packageName);
+    }
+
+    /**
+     * @return {@code false} if the given package has been disable from enforcing the service
+     * restart backoff policy, used by {@link ActivityManagerShellCommand}.
+     */
+    @GuardedBy("mAm")
+    boolean isServiceRestartBackoffEnabledLocked(@NonNull String packageName) {
+        return !mRestartBackoffDisabledPackages.contains(packageName);
+    }
+
     private String bringUpServiceLocked(ServiceRecord r, int intentFlags, boolean execInFg,
             boolean whileRestarting, boolean permissionsReviewRequired, boolean packageFrozen,
             boolean enqueueOomAdj)
@@ -4431,6 +4498,7 @@
                 mPendingBringups.removeAt(i);
             }
         }
+        removeServiceRestartBackoffEnabledLocked(packageName);
     }
 
     void cleanUpServices(int userId, ComponentName component, Intent baseIntent) {
diff --git a/services/core/java/com/android/server/am/ActivityManagerService.java b/services/core/java/com/android/server/am/ActivityManagerService.java
index 0f72c3e..14ca9da 100644
--- a/services/core/java/com/android/server/am/ActivityManagerService.java
+++ b/services/core/java/com/android/server/am/ActivityManagerService.java
@@ -8436,6 +8436,26 @@
         }
     }
 
+    /**
+     * Toggle service restart backoff policy, used by {@link ActivityManagerShellCommand}.
+     */
+    void setServiceRestartBackoffEnabled(@NonNull String packageName, boolean enable,
+            @NonNull String reason) {
+        synchronized (this) {
+            mServices.setServiceRestartBackoffEnabledLocked(packageName, enable, reason);
+        }
+    }
+
+    /**
+     * @return {@code false} if the given package has been disable from enforcing the service
+     * restart backoff policy, used by {@link ActivityManagerShellCommand}.
+     */
+    boolean isServiceRestartBackoffEnabled(@NonNull String packageName) {
+        synchronized (this) {
+            return mServices.isServiceRestartBackoffEnabledLocked(packageName);
+        }
+    }
+
     @Override
     public void onShellCommand(FileDescriptor in, FileDescriptor out,
             FileDescriptor err, String[] args, ShellCallback callback,
diff --git a/services/core/java/com/android/server/am/ActivityManagerShellCommand.java b/services/core/java/com/android/server/am/ActivityManagerShellCommand.java
index b8e06ee..42aac29 100644
--- a/services/core/java/com/android/server/am/ActivityManagerShellCommand.java
+++ b/services/core/java/com/android/server/am/ActivityManagerShellCommand.java
@@ -318,6 +318,8 @@
                     return runRefreshSettingsCache();
                 case "memory-factor":
                     return runMemoryFactor(pw);
+                case "service-restart-backoff":
+                    return runServiceRestartBackoff(pw);
                 default:
                     return handleDefaultCommands(cmd);
             }
@@ -3095,6 +3097,28 @@
         }
     }
 
+    private int runServiceRestartBackoff(PrintWriter pw) throws RemoteException {
+        mInternal.enforceCallingPermission(android.Manifest.permission.SET_PROCESS_LIMIT,
+                "runServiceRestartBackoff()");
+
+        final String opt = getNextArgRequired();
+        switch (opt) {
+            case "enable":
+                mInternal.setServiceRestartBackoffEnabled(getNextArgRequired(), true, "shell");
+                return 0;
+            case "disable":
+                mInternal.setServiceRestartBackoffEnabled(getNextArgRequired(), false, "shell");
+                return 0;
+            case "show":
+                pw.println(mInternal.isServiceRestartBackoffEnabled(getNextArgRequired())
+                        ? "enabled" : "disabled");
+                return 0;
+            default:
+                getErrPrintWriter().println("Error: unknown command '" + opt + "'");
+                return -1;
+        }
+    }
+
     private Resources getResources(PrintWriter pw) throws RemoteException {
         // system resources does not contain all the device configuration, construct it manually.
         Configuration config = mInterface.getConfiguration();
@@ -3418,6 +3442,11 @@
             pw.println("            Shows the existing memory pressure factor");
             pw.println("         reset");
             pw.println("            Removes existing override for memory pressure factor");
+            pw.println("  service-restart-backoff <COMMAND> [...]: sub-commands to toggle service restart backoff policy.");
+            pw.println("         enable|disable <PACKAGE_NAME>");
+            pw.println("            Toggles the restart backoff policy on/off for <PACKAGE_NAME>.");
+            pw.println("         show <PACKAGE_NAME>");
+            pw.println("            Shows the restart backoff policy state for <PACKAGE_NAME>.");
             pw.println();
             Intent.printIntentArgsHelp(pw, "");
         }
diff --git a/services/tests/servicestests/AndroidManifest.xml b/services/tests/servicestests/AndroidManifest.xml
index 9513c6e..7c30b45 100644
--- a/services/tests/servicestests/AndroidManifest.xml
+++ b/services/tests/servicestests/AndroidManifest.xml
@@ -91,6 +91,7 @@
     <uses-permission android:name="android.permission.VIBRATE_ALWAYS_ON"/>
     <uses-permission android:name="android.permission.CONTROL_DEVICE_STATE"/>
     <uses-permission android:name="android.permission.READ_PROJECTION_STATE"/>
+    <uses-permission android:name="android.permission.KILL_UID"/>
 
     <!-- Uses API introduced in O (26) -->
     <uses-sdk android:minSdkVersion="1"
diff --git a/services/tests/servicestests/AndroidTest.xml b/services/tests/servicestests/AndroidTest.xml
index d34f783..5a0f1ee 100644
--- a/services/tests/servicestests/AndroidTest.xml
+++ b/services/tests/servicestests/AndroidTest.xml
@@ -23,7 +23,9 @@
         <option name="test-file-name" value="JobTestApp.apk" />
         <option name="test-file-name" value="ConnTestApp.apk" />
         <option name="test-file-name" value="SuspendTestApp.apk" />
-        <option name="test-file-name" value="SimpleServiceTestApp.apk" />
+        <option name="test-file-name" value="SimpleServiceTestApp1.apk" />
+        <option name="test-file-name" value="SimpleServiceTestApp2.apk" />
+        <option name="test-file-name" value="SimpleServiceTestApp3.apk" />
     </target_preparer>
 
     <option name="test-tag" value="FrameworksServicesTests" />
diff --git a/services/tests/servicestests/src/com/android/server/am/ActivityManagerTest.java b/services/tests/servicestests/src/com/android/server/am/ActivityManagerTest.java
index e13597d..e04841b 100644
--- a/services/tests/servicestests/src/com/android/server/am/ActivityManagerTest.java
+++ b/services/tests/servicestests/src/com/android/server/am/ActivityManagerTest.java
@@ -73,8 +73,9 @@
 public class ActivityManagerTest {
     private static final String TAG = "ActivityManagerTest";
 
-    private static final String TEST_APP = "com.android.servicestests.apps.simpleservicetestapp";
-    private static final String TEST_CLASS = TEST_APP + ".SimpleService";
+    private static final String TEST_APP = "com.android.servicestests.apps.simpleservicetestapp1";
+    private static final String TEST_CLASS =
+            "com.android.servicestests.apps.simpleservicetestapp.SimpleService";
     private static final int TEST_LOOPS = 100;
     private static final long AWAIT_TIMEOUT = 2000;
     private static final long CHECK_INTERVAL = 100;
diff --git a/services/tests/servicestests/src/com/android/server/am/ServiceRestarterTest.java b/services/tests/servicestests/src/com/android/server/am/ServiceRestarterTest.java
new file mode 100644
index 0000000..10f4c05
--- /dev/null
+++ b/services/tests/servicestests/src/com/android/server/am/ServiceRestarterTest.java
@@ -0,0 +1,263 @@
+/*
+ * Copyright (C) 2021 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.am;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import android.app.ActivityManager;
+import android.app.ActivityManager.OnUidImportanceListener;
+import android.app.ActivityManager.RunningAppProcessInfo;
+import android.app.Instrumentation;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.os.SystemClock;
+import android.test.suitebuilder.annotation.LargeTest;
+import android.util.Log;
+
+import androidx.test.InstrumentationRegistry;
+import androidx.test.runner.AndroidJUnit4;
+
+import com.android.compatibility.common.util.SystemUtil;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Build/Install/Run:
+ *  atest FrameworksServicesTests:ServiceRestarterTest
+ */
+@RunWith(AndroidJUnit4.class)
+public final class ServiceRestarterTest {
+    private static final String TAG = "ServiceRestarterTest";
+
+    private static final String TEST_PACKAGE1_NAME =
+            "com.android.servicestests.apps.simpleservicetestapp1";
+    private static final String TEST_PACKAGE2_NAME =
+            "com.android.servicestests.apps.simpleservicetestapp2";
+    private static final String TEST_PACKAGE3_NAME =
+            "com.android.servicestests.apps.simpleservicetestapp3";
+    private static final String TEST_SERVICE_NAME =
+            "com.android.servicestests.apps.simpleservicetestapp.SimpleService";
+
+    private static final long WAIT_MS = 5 * 1000;
+    private static final long WAIT_LONG_MS = 30 * 1000;
+
+    private static final int ACTION_START = 1;
+    private static final int ACTION_KILL = 2;
+    private static final int ACTION_WAIT = 4;
+    private static final int ACTION_STOPPKG = 8;
+    private static final int ACTION_ALL = ACTION_START | ACTION_KILL | ACTION_WAIT | ACTION_STOPPKG;
+
+    private Context mContext;
+    private Instrumentation mInstrumentation;
+    private int mTestPackage1Uid;
+    private int mTestPackage2Uid;
+    private int mTestPackage3Uid;
+
+    @Before
+    public void setUp() throws Exception {
+        mInstrumentation = InstrumentationRegistry.getInstrumentation();
+        mContext = InstrumentationRegistry.getContext();
+        ApplicationInfo ai = mContext.getPackageManager().getApplicationInfo(TEST_PACKAGE1_NAME, 0);
+        mTestPackage1Uid = ai.uid;
+        ai = mContext.getPackageManager().getApplicationInfo(TEST_PACKAGE2_NAME, 0);
+        mTestPackage2Uid = ai.uid;
+        ai = mContext.getPackageManager().getApplicationInfo(TEST_PACKAGE3_NAME, 0);
+        mTestPackage3Uid = ai.uid;
+    }
+
+    @LargeTest
+    @Test
+    public void testDisableServiceRestartBackoff() throws Exception {
+        final ActivityManager am = mContext.getSystemService(ActivityManager.class);
+        final MyUidImportanceListener uid1Listener1 = new MyUidImportanceListener(mTestPackage1Uid);
+        final MyUidImportanceListener uid1Listener2 = new MyUidImportanceListener(mTestPackage1Uid);
+        final MyUidImportanceListener uid2Listener1 = new MyUidImportanceListener(mTestPackage2Uid);
+        final MyUidImportanceListener uid2Listener2 = new MyUidImportanceListener(mTestPackage2Uid);
+        final MyUidImportanceListener uid3Listener1 = new MyUidImportanceListener(mTestPackage3Uid);
+        final MyUidImportanceListener uid3Listener2 = new MyUidImportanceListener(mTestPackage3Uid);
+        try {
+            am.addOnUidImportanceListener(uid1Listener1, RunningAppProcessInfo.IMPORTANCE_SERVICE);
+            am.addOnUidImportanceListener(uid1Listener2, RunningAppProcessInfo.IMPORTANCE_GONE);
+            am.addOnUidImportanceListener(uid2Listener1, RunningAppProcessInfo.IMPORTANCE_SERVICE);
+            am.addOnUidImportanceListener(uid2Listener2, RunningAppProcessInfo.IMPORTANCE_GONE);
+            am.addOnUidImportanceListener(uid3Listener1, RunningAppProcessInfo.IMPORTANCE_SERVICE);
+            am.addOnUidImportanceListener(uid3Listener2, RunningAppProcessInfo.IMPORTANCE_GONE);
+            executeShellCmd("cmd deviceidle whitelist +" + TEST_PACKAGE1_NAME);
+            executeShellCmd("cmd deviceidle whitelist +" + TEST_PACKAGE2_NAME);
+            executeShellCmd("cmd deviceidle whitelist +" + TEST_PACKAGE3_NAME);
+
+            // Issue the command to enable service backoff policy for app2.
+            executeShellCmd("am service-restart-backoff enable " + TEST_PACKAGE2_NAME);
+            // Test restarts in normal case
+            final long[] ts1 = startKillAndRestart(am, ACTION_START | ACTION_KILL | ACTION_WAIT,
+                    uid1Listener1, uid1Listener2, uid2Listener1, uid2Listener2,
+                    uid3Listener1, uid3Listener2, Long.MAX_VALUE);
+            assertTrue("app1 restart should be before app2", ts1[1] < ts1[2]);
+            assertTrue("app2 restart should be before app3", ts1[2] < ts1[3]);
+
+            // Issue the command to disable service backoff policy for app2.
+            executeShellCmd("am service-restart-backoff disable " + TEST_PACKAGE2_NAME);
+            // Test restarts again.
+            final long[] ts2 = startKillAndRestart(am, ACTION_KILL | ACTION_WAIT | ACTION_STOPPKG,
+                    uid1Listener1, uid1Listener2, uid2Listener1,
+                    uid2Listener2, uid3Listener1, uid3Listener2, Long.MAX_VALUE);
+            assertTrue("app2 restart should be before app1", ts2[2] < ts2[1]);
+            assertTrue("app1 restart should be before app3", ts2[1] < ts2[3]);
+            assertTrue("app2 should be restart in a very short moment", ts2[2] - ts2[0] < WAIT_MS);
+
+            // Issue the command to enable service backoff policy for app2.
+            executeShellCmd("am service-restart-backoff enable " + TEST_PACKAGE2_NAME);
+            // Test restarts again.
+            final long[] ts3 = startKillAndRestart(am, ACTION_ALL, uid1Listener1, uid1Listener2,
+                    uid2Listener1, uid2Listener2, uid3Listener1, uid3Listener2, Long.MAX_VALUE);
+            assertTrue("app1 restart should be before app2", ts3[1] < ts3[2]);
+            assertTrue("app2 restart should be before app3", ts3[2] < ts3[3]);
+
+        } finally {
+            executeShellCmd("cmd deviceidle whitelist -" + TEST_PACKAGE1_NAME);
+            executeShellCmd("cmd deviceidle whitelist -" + TEST_PACKAGE2_NAME);
+            executeShellCmd("cmd deviceidle whitelist -" + TEST_PACKAGE3_NAME);
+            executeShellCmd("am service-restart-backoff enable " + TEST_PACKAGE2_NAME);
+            am.removeOnUidImportanceListener(uid1Listener1);
+            am.removeOnUidImportanceListener(uid1Listener2);
+            am.removeOnUidImportanceListener(uid2Listener1);
+            am.removeOnUidImportanceListener(uid2Listener2);
+            am.removeOnUidImportanceListener(uid3Listener1);
+            am.removeOnUidImportanceListener(uid3Listener2);
+            am.forceStopPackage(TEST_PACKAGE1_NAME);
+            am.forceStopPackage(TEST_PACKAGE2_NAME);
+            am.forceStopPackage(TEST_PACKAGE3_NAME);
+        }
+    }
+
+    private long[] startKillAndRestart(ActivityManager am, int action,
+            MyUidImportanceListener uid1Listener1, MyUidImportanceListener uid1Listener2,
+            MyUidImportanceListener uid2Listener1, MyUidImportanceListener uid2Listener2,
+            MyUidImportanceListener uid3Listener1, MyUidImportanceListener uid3Listener2,
+            long waitDuration) throws Exception {
+        final long[] res = new long[4];
+        // Test restarts in normal condition.
+        if ((action & ACTION_START) != 0) {
+            startServiceAndWait(TEST_PACKAGE1_NAME, uid1Listener1, WAIT_MS);
+            startServiceAndWait(TEST_PACKAGE2_NAME, uid2Listener1, WAIT_MS);
+            startServiceAndWait(TEST_PACKAGE3_NAME, uid3Listener1, WAIT_MS);
+        }
+
+        if ((action & ACTION_KILL) != 0) {
+            final long now = res[0] = SystemClock.uptimeMillis();
+            killUidAndWait(am, mTestPackage1Uid, uid1Listener2, WAIT_MS);
+            killUidAndWait(am, mTestPackage2Uid, uid2Listener2, WAIT_MS);
+            killUidAndWait(am, mTestPackage3Uid, uid3Listener2, WAIT_MS);
+        }
+
+        if ((action & ACTION_WAIT) != 0) {
+            assertTrue("Timed out to restart " + TEST_PACKAGE1_NAME, uid1Listener1.waitFor(
+                    RunningAppProcessInfo.IMPORTANCE_SERVICE, waitDuration));
+            assertTrue("Timed out to restart " + TEST_PACKAGE2_NAME, uid2Listener1.waitFor(
+                    RunningAppProcessInfo.IMPORTANCE_SERVICE, waitDuration));
+            assertTrue("Timed out to restart " + TEST_PACKAGE3_NAME, uid3Listener1.waitFor(
+                    RunningAppProcessInfo.IMPORTANCE_SERVICE, waitDuration));
+            res[1] = uid1Listener1.mCurrentTimestamp;
+            res[2] = uid2Listener1.mCurrentTimestamp;
+            res[3] = uid3Listener1.mCurrentTimestamp;
+        }
+
+        if ((action & ACTION_STOPPKG) != 0) {
+            // Force stop these packages to reset the backoff delays.
+            am.forceStopPackage(TEST_PACKAGE1_NAME);
+            am.forceStopPackage(TEST_PACKAGE2_NAME);
+            am.forceStopPackage(TEST_PACKAGE3_NAME);
+            assertTrue("Timed out to force-stop " + mTestPackage1Uid,
+                    uid1Listener2.waitFor(RunningAppProcessInfo.IMPORTANCE_GONE, WAIT_MS));
+            assertTrue("Timed out to force-stop " + mTestPackage2Uid,
+                    uid2Listener2.waitFor(RunningAppProcessInfo.IMPORTANCE_GONE, WAIT_MS));
+            assertTrue("Timed out to force-stop " + mTestPackage3Uid,
+                    uid3Listener2.waitFor(RunningAppProcessInfo.IMPORTANCE_GONE, WAIT_MS));
+        }
+        return res;
+    }
+
+    private void startServiceAndWait(String pkgName, MyUidImportanceListener uidListener,
+            long timeout) throws Exception {
+        final Intent intent = new Intent();
+        final ComponentName cn = ComponentName.unflattenFromString(
+                pkgName + "/" + TEST_SERVICE_NAME);
+        intent.setComponent(cn);
+        Log.i(TAG, "Starting service " + cn);
+        assertNotNull(mContext.startService(intent));
+        assertTrue("Timed out to start service " + cn,
+                uidListener.waitFor(RunningAppProcessInfo.IMPORTANCE_SERVICE, timeout));
+    }
+
+    private void killUidAndWait(ActivityManager am, int uid, MyUidImportanceListener uidListener,
+            long timeout) throws Exception {
+        am.killUid(uid, "test service restart");
+        assertTrue("Timed out to kill " + uid,
+                uidListener.waitFor(RunningAppProcessInfo.IMPORTANCE_GONE, timeout));
+    }
+
+    private String executeShellCmd(String cmd) throws Exception {
+        final String result = SystemUtil.runShellCommand(mInstrumentation, cmd);
+        Log.d(TAG, String.format("Output for '%s': %s", cmd, result));
+        return result;
+    }
+
+    private static class MyUidImportanceListener implements OnUidImportanceListener {
+        final CountDownLatch[] mLatchHolder = new CountDownLatch[1];
+        private final int mExpectedUid;
+        private int mExpectedImportance;
+        private int mCurrentImportance = RunningAppProcessInfo.IMPORTANCE_GONE;
+        long mCurrentTimestamp;
+
+        MyUidImportanceListener(int uid) {
+            mExpectedUid = uid;
+        }
+
+        @Override
+        public void onUidImportance(int uid, int importance) {
+            if (uid == mExpectedUid) {
+                mCurrentTimestamp = SystemClock.uptimeMillis();
+                synchronized (this) {
+                    if (importance == mExpectedImportance && mLatchHolder[0] != null) {
+                        mLatchHolder[0].countDown();
+                    }
+                    mCurrentImportance = importance;
+                }
+                Log.i(TAG, "uid " + uid + " importance: " + importance);
+            }
+        }
+
+        boolean waitFor(int expectedImportance, long timeout) throws Exception {
+            synchronized (this) {
+                mExpectedImportance = expectedImportance;
+                if (mCurrentImportance == expectedImportance) {
+                    return true;
+                }
+                mLatchHolder[0] = new CountDownLatch(1);
+            }
+            return mLatchHolder[0].await(timeout, TimeUnit.MILLISECONDS);
+        }
+    }
+}
diff --git a/services/tests/servicestests/test-apps/SimpleServiceTestApp/Android.bp b/services/tests/servicestests/test-apps/SimpleServiceTestApp/Android.bp
index 50b89d4..5550f7d 100644
--- a/services/tests/servicestests/test-apps/SimpleServiceTestApp/Android.bp
+++ b/services/tests/servicestests/test-apps/SimpleServiceTestApp/Android.bp
@@ -22,7 +22,7 @@
 }
 
 android_test_helper_app {
-    name: "SimpleServiceTestApp",
+    name: "SimpleServiceTestApp1",
 
     test_suites: ["device-tests"],
 
@@ -36,4 +36,47 @@
     optimize: {
         enabled: false,
     },
+    aaptflags: [
+        "--rename-manifest-package com.android.servicestests.apps.simpleservicetestapp1",
+    ],
+}
+
+android_test_helper_app {
+    name: "SimpleServiceTestApp2",
+
+    test_suites: ["device-tests"],
+
+    srcs: ["**/*.java"],
+
+    platform_apis: true,
+    certificate: "platform",
+    dex_preopt: {
+        enabled: false,
+    },
+    optimize: {
+        enabled: false,
+    },
+    aaptflags: [
+        "--rename-manifest-package com.android.servicestests.apps.simpleservicetestapp2",
+    ],
+}
+
+android_test_helper_app {
+    name: "SimpleServiceTestApp3",
+
+    test_suites: ["device-tests"],
+
+    srcs: ["**/*.java"],
+
+    platform_apis: true,
+    certificate: "platform",
+    dex_preopt: {
+        enabled: false,
+    },
+    optimize: {
+        enabled: false,
+    },
+    aaptflags: [
+        "--rename-manifest-package com.android.servicestests.apps.simpleservicetestapp3",
+    ],
 }
diff --git a/services/tests/servicestests/test-apps/SimpleServiceTestApp/src/com/android/servicestests/apps/simpleservicetestapp/SimpleService.java b/services/tests/servicestests/test-apps/SimpleServiceTestApp/src/com/android/servicestests/apps/simpleservicetestapp/SimpleService.java
index 75f71d6..674ce8a 100644
--- a/services/tests/servicestests/test-apps/SimpleServiceTestApp/src/com/android/servicestests/apps/simpleservicetestapp/SimpleService.java
+++ b/services/tests/servicestests/test-apps/SimpleServiceTestApp/src/com/android/servicestests/apps/simpleservicetestapp/SimpleService.java
@@ -21,8 +21,11 @@
 import android.os.IBinder;
 import android.os.IRemoteCallback;
 import android.os.Process;
+import android.util.Log;
 
 public class SimpleService extends Service {
+    private static final String TAG = "SimpleService";
+
     private final IRemoteCallback.Stub mBinder = new IRemoteCallback.Stub() {
         @Override
         public void sendResult(Bundle bundle) {
@@ -31,6 +34,12 @@
     };
 
     @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        Log.i(TAG, "onStartCommand");
+        return START_STICKY;
+    }
+
+    @Override
     public IBinder onBind(Intent intent) {
         return mBinder;
     }