From f6f9f2d0256930ce0bb4913b2260b8480914edc2 Mon Sep 17 00:00:00 2001 From: Dianne Hackborn Date: Fri, 21 Aug 2009 16:26:03 -0700 Subject: Add more control over a service's start state. One of the problems I have been noticing is background services sitting around running and using resources. Some times this is due to the app developer doing this when they shouldn't, but there are also a number of issues with the current Service interaction model that make it very difficult (or impossible) to avoid getting services stuck in the started state. This is a change/enhancement to the Service API to try to address this. The main change is that Service.onStart() has been deprecated, replaced with a new Service.onStartCommand() that allows the service to better control how the system should manage it. The key part here is a new result code returned by the function, telling the system what it should do with the service afterwards: - START_STICKY is basically the same as the previous behavior, where we usually leave the service running. The only difference is that it if it gets restarted because its process is killed, onStartCommand() will be called on the new service with a null Intent instead of not being called at all. - START_NOT_STICKY says that, upon returning to the system, if its process is killed with no remaining start commands to deliver, then the service will be stopped instead of restarted. This makes a lot more sense for services that are intended to only run while executing commands sent to them. - START_REDELIVER_INTENT is like START_NOT_STICKY, except if the service's process is killed before it calls stopSelf() for a given intent, that intent will be re-delivered to it until it completes (unless after 4 or more tries it still can't complete, at which point we give up). Change-Id: I978f5ca420d70023d1b5e7f97de639d09381f8ad --- api/current.xml | 118 +++++++++++++ core/java/android/app/ActivityManagerNative.java | 11 +- core/java/android/app/ActivityThread.java | 19 +- core/java/android/app/ApplicationThreadNative.java | 20 ++- core/java/android/app/IActivityManager.java | 3 +- core/java/android/app/IApplicationThread.java | 3 +- core/java/android/app/IntentService.java | 21 ++- core/java/android/app/Service.java | 113 +++++++++++- core/java/android/os/Build.java | 13 ++ .../android/server/am/ActivityManagerService.java | 196 +++++++++++++++++++-- .../java/com/android/server/am/ServiceRecord.java | 68 ++++++- 11 files changed, 545 insertions(+), 40 deletions(-) diff --git a/api/current.xml b/api/current.xml index 7fad5052a605..bb70f6f8a0ce 100644 --- a/api/current.xml +++ b/api/current.xml @@ -21568,6 +21568,19 @@ + + + + + + + + + + + + @@ -23866,6 +23896,83 @@ + + + + + + + + + + + + + + + + not call + * {@link #onStartCommand} unless there has been a new call to + * {@link Context#startService Context.startService(Intent)} with a new + * Intent to deliver. + * + *

This mode makes sense for things that will be explicitly started + * and stopped to run for arbitrary periods of time, such as a service + * performing background music playback. + */ + public static final int START_STICKY = 1; + + /** + * Constant to return from {@link #onStartCommand}: if this service's + * process is killed while it is started (after returning from + * {@link #onStartCommand}), and there are no new start intents to + * deliver to it, then take the service out of the started state and + * don't recreate until a future explicit call to + * {@link Context#startService Context.startService(Intent)}. + * + *

This mode makes sense for things that want to do some work as a + * result of being started, but can be stopped when under memory pressure + * and will explicit start themselves again later to do more work. An + * example of such a service would be one that polls for data from + * a server: it could schedule an alarm to poll every N minutes by having + * the alarm start its service. When its {@link #onStartCommand} is + * called from the alarm, it schedules a new alarm for N minutes later, + * and spawns a thread to do its networking. If its process is killed + * while doing that check, the service will not be restarted until the + * alarm goes off. + */ + public static final int START_NOT_STICKY = 2; + + /** + * Constant to return from {@link #onStartCommand}: if this service's + * process is killed while it is started (after returning from + * {@link #onStartCommand}), then it will be scheduled for a restart + * and the last delivered Intent re-delivered to it again via + * {@link #onStartCommand}. This Intent will remain scheduled for + * redelivery until the service calls {@link #stopSelf(int)} with the + * start ID provided to {@link #onStartCommand}. + */ + public static final int START_REDELIVER_INTENT = 3; + + /** + * This flag is set in {@link #onStartCommand} if the Intent is a + * re-delivery of a previously delivered intent, because the service + * had previously returned {@link #START_REDELIVER_INTENT} but had been + * killed before calling {@link #stopSelf(int)} for that Intent. + */ + public static final int START_FLAG_REDELIVERY = 0x0001; + + /** + * This flag is set in {@link #onStartCommand} if the Intent is a + * a retry because the original attempt never got to or returned from + * {@link #onStartCommand(Intent, int, int)}. + */ + public static final int START_FLAG_RETRY = 0x0002; + /** * Called by the system every time a client explicitly starts the service by calling * {@link android.content.Context#startService}, providing the arguments it supplied and a * unique integer token representing the start request. Do not call this method directly. - * + * + *

For backwards compatibility, the default implementation calls + * {@link #onStart} and returns either {@link #START_STICKY} + * or {@link #START_STICKY_COMPATIBILITY}. + * * @param intent The Intent supplied to {@link android.content.Context#startService}, - * as given. + * as given. This may be null if the service is being restarted after + * its process has gone away, and it had previously returned anything + * except {@link #START_STICKY_COMPATIBILITY}. + * @param flags Additional data about this start request. Currently either + * 0, {@link #START_FLAG_REDELIVERY}, or {@link #START_FLAG_RETRY}. * @param startId A unique integer representing this specific request to - * start. Use with {@link #stopSelfResult(int)}. + * start. Use with {@link #stopSelfResult(int)}. + * + * @return The return value indicates what semantics the system should + * use for the service's current started state. It may be one of the + * constants associated with the {@link #START_CONTINUATION_MASK} bits. * * @see #stopSelfResult(int) */ - public void onStart(Intent intent, int startId) { + public int onStartCommand(Intent intent, int flags, int startId) { + onStart(intent, startId); + return mStartCompatibility ? START_STICKY_COMPATIBILITY : START_STICKY; } - + /** * Called by the system to notify a Service that it is no longer used and is being removed. The * service should clean up an resources it holds (threads, registered @@ -393,6 +493,8 @@ public abstract class Service extends ContextWrapper implements ComponentCallbac mToken = token; mApplication = application; mActivityManager = (IActivityManager)activityManager; + mStartCompatibility = getApplicationInfo().targetSdkVersion + < Build.VERSION_CODES.ECLAIR; } final String getClassName() { @@ -405,4 +507,5 @@ public abstract class Service extends ContextWrapper implements ComponentCallbac private IBinder mToken = null; private Application mApplication = null; private IActivityManager mActivityManager = null; + private boolean mStartCompatibility = false; } diff --git a/core/java/android/os/Build.java b/core/java/android/os/Build.java index 1775a4b33ca7..ffd26863e538 100644 --- a/core/java/android/os/Build.java +++ b/core/java/android/os/Build.java @@ -132,6 +132,19 @@ public class Build { * */ public static final int DONUT = 4; + /** + * Current work on "Eclair" development branch. + * + *

Applications targeting this or a later release will get these + * new changes in behavior:

+ * + */ + public static final int ECLAIR = CUR_DEVELOPMENT; } /** The type of build, like "user" or "eng". */ diff --git a/services/java/com/android/server/am/ActivityManagerService.java b/services/java/com/android/server/am/ActivityManagerService.java index ee9fa36c5247..a4b0685bb979 100644 --- a/services/java/com/android/server/am/ActivityManagerService.java +++ b/services/java/com/android/server/am/ActivityManagerService.java @@ -42,6 +42,7 @@ import android.app.Instrumentation; import android.app.Notification; import android.app.PendingIntent; import android.app.ResultInfo; +import android.app.Service; import android.backup.IBackupManager; import android.content.ActivityNotFoundException; import android.content.ComponentName; @@ -9385,7 +9386,9 @@ public final class ActivityManagerService extends ActivityManagerNative implemen sr.app = null; sr.executeNesting = 0; mStoppingServices.remove(sr); - if (sr.bindings.size() > 0) { + + boolean hasClients = sr.bindings.size() > 0; + if (hasClients) { Iterator bindings = sr.bindings.values().iterator(); while (bindings.hasNext()) { @@ -9406,7 +9409,20 @@ public final class ActivityManagerService extends ActivityManagerNative implemen } else if (!allowRestart) { bringDownServiceLocked(sr, true); } else { - scheduleServiceRestartLocked(sr); + boolean canceled = scheduleServiceRestartLocked(sr, true); + + // Should the service remain running? Note that in the + // extreme case of so many attempts to deliver a command + // that it failed, that we also will stop it here. + if (sr.startRequested && (sr.stopIfKilled || canceled)) { + if (sr.pendingStarts.size() == 0) { + sr.startRequested = false; + if (!hasClients) { + // Whoops, no reason to restart! + bringDownServiceLocked(sr, true); + } + } + } } } @@ -9845,35 +9861,55 @@ public final class ActivityManagerService extends ActivityManagerNative implemen private final void sendServiceArgsLocked(ServiceRecord r, boolean oomAdjusted) { - final int N = r.startArgs.size(); + final int N = r.pendingStarts.size(); if (N == 0) { return; } - final int BASEID = r.lastStartId - N + 1; int i = 0; while (i < N) { try { - Intent args = r.startArgs.get(i); + ServiceRecord.StartItem si = r.pendingStarts.get(i); if (DEBUG_SERVICE) Log.v(TAG, "Sending arguments to service: " - + r.name + " " + r.intent + " args=" + args); + + r.name + " " + r.intent + " args=" + si.intent); + if (si.intent == null && N > 0) { + // If somehow we got a dummy start at the front, then + // just drop it here. + i++; + continue; + } bumpServiceExecutingLocked(r); if (!oomAdjusted) { oomAdjusted = true; updateOomAdjLocked(r.app); } - r.app.thread.scheduleServiceArgs(r, BASEID+i, args); + int flags = 0; + if (si.deliveryCount > 0) { + flags |= Service.START_FLAG_RETRY; + } + if (si.doneExecutingCount > 0) { + flags |= Service.START_FLAG_REDELIVERY; + } + r.app.thread.scheduleServiceArgs(r, si.id, flags, si.intent); + si.deliveredTime = SystemClock.uptimeMillis(); + r.deliveredStarts.add(si); + si.deliveryCount++; i++; + } catch (RemoteException e) { + // Remote process gone... we'll let the normal cleanup take + // care of this. + break; } catch (Exception e) { + Log.w(TAG, "Unexpected exception", e); break; } } if (i == N) { - r.startArgs.clear(); + r.pendingStarts.clear(); } else { while (i > 0) { - r.startArgs.remove(0); i--; + r.pendingStarts.remove(i); } } } @@ -9942,19 +9978,61 @@ public final class ActivityManagerService extends ActivityManagerNative implemen } finally { if (!created) { app.services.remove(r); - scheduleServiceRestartLocked(r); + scheduleServiceRestartLocked(r, false); } } requestServiceBindingsLocked(r); + + // If the service is in the started state, and there are no + // pending arguments, then fake up one so its onStartCommand() will + // be called. + if (r.startRequested && r.callStart && r.pendingStarts.size() == 0) { + r.lastStartId++; + if (r.lastStartId < 1) { + r.lastStartId = 1; + } + r.pendingStarts.add(new ServiceRecord.StartItem(r.lastStartId, null)); + } + sendServiceArgsLocked(r, true); } - private final void scheduleServiceRestartLocked(ServiceRecord r) { + private final boolean scheduleServiceRestartLocked(ServiceRecord r, + boolean allowCancel) { + boolean canceled = false; + + long minDuration = SERVICE_RESTART_DURATION; + long resetTime = minDuration*2*2*2; + + // Any delivered but not yet finished starts should be put back + // on the pending list. + final int N = r.deliveredStarts.size(); + if (N > 0) { + for (int i=N-1; i>=0; i--) { + ServiceRecord.StartItem si = r.deliveredStarts.get(i); + if (si.intent == null) { + // We'll generate this again if needed. + } else if (!allowCancel || (si.deliveryCount < ServiceRecord.MAX_DELIVERY_COUNT + && si.doneExecutingCount < ServiceRecord.MAX_DONE_EXECUTING_COUNT)) { + r.pendingStarts.add(0, si); + long dur = SystemClock.uptimeMillis() - si.deliveredTime; + dur *= 2; + if (minDuration < dur) minDuration = dur; + if (resetTime < dur) resetTime = dur; + } else { + Log.w(TAG, "Canceling start item " + si.intent + " in service " + + r.name); + canceled = true; + } + } + r.deliveredStarts.clear(); + } + r.totalRestartCount++; if (r.restartDelay == 0) { r.restartCount++; - r.restartDelay = SERVICE_RESTART_DURATION; + r.restartDelay = minDuration; } else { // If it has been a "reasonably long time" since the service // was started, then reset our restart duration back to @@ -9962,17 +10040,21 @@ public final class ActivityManagerService extends ActivityManagerNative implemen // on a service that just occasionally gets killed (which is // a normal case, due to process being killed to reclaim memory). long now = SystemClock.uptimeMillis(); - if (now > (r.restartTime+(SERVICE_RESTART_DURATION*2*2*2))) { + if (now > (r.restartTime+resetTime)) { r.restartCount = 1; - r.restartDelay = SERVICE_RESTART_DURATION; + r.restartDelay = minDuration; } else { - r.restartDelay *= 2; + r.restartDelay *= 4; + if (r.restartDelay < minDuration) { + r.restartDelay = minDuration; + } } } if (!mRestartingServices.contains(r)) { mRestartingServices.add(r); } r.cancelNotification(); + mHandler.removeCallbacks(r.restarter); mHandler.postDelayed(r.restarter, r.restartDelay); r.nextRestartTime = SystemClock.uptimeMillis() + r.restartDelay; @@ -9985,6 +10067,8 @@ public final class ActivityManagerService extends ActivityManagerNative implemen msg.what = SERVICE_ERROR_MSG; msg.obj = r; mHandler.sendMessage(msg); + + return canceled; } final void performServiceRestartLocked(ServiceRecord r) { @@ -10146,6 +10230,10 @@ public final class ActivityManagerService extends ActivityManagerNative implemen r.foregroundId = 0; r.foregroundNoti = null; + // Clear start entries. + r.deliveredStarts.clear(); + r.pendingStarts.clear(); + if (r.app != null) { synchronized (r.stats.getBatteryStats()) { r.stats.stopLaunchedLocked(); @@ -10207,11 +10295,12 @@ public final class ActivityManagerService extends ActivityManagerNative implemen + r.shortName); } r.startRequested = true; - r.startArgs.add(service); + r.callStart = false; r.lastStartId++; if (r.lastStartId < 1) { r.lastStartId = 1; } + r.pendingStarts.add(new ServiceRecord.StartItem(r.lastStartId, service)); r.lastActivity = SystemClock.uptimeMillis(); synchronized (r.stats.getBatteryStats()) { r.stats.startRunningLocked(); @@ -10279,6 +10368,7 @@ public final class ActivityManagerService extends ActivityManagerNative implemen r.record.stats.stopRunningLocked(); } r.record.startRequested = false; + r.record.callStart = false; final long origId = Binder.clearCallingIdentity(); bringDownServiceLocked(r.record, false); Binder.restoreCallingIdentity(origId); @@ -10327,10 +10417,35 @@ public final class ActivityManagerService extends ActivityManagerNative implemen if (DEBUG_SERVICE) Log.v(TAG, "stopServiceToken: " + className + " " + token + " startId=" + startId); ServiceRecord r = findServiceLocked(className, token); - if (r != null && (startId < 0 || r.lastStartId == startId)) { + if (r != null) { + if (startId >= 0) { + // Asked to only stop if done with all work. Note that + // to avoid leaks, we will take this as dropping all + // start items up to and including this one. + ServiceRecord.StartItem si = r.findDeliveredStart(startId, false); + if (si != null) { + while (r.deliveredStarts.size() > 0) { + if (r.deliveredStarts.remove(0) == si) { + break; + } + } + } + + if (r.lastStartId != startId) { + return false; + } + + if (r.deliveredStarts.size() > 0) { + Log.w(TAG, "stopServiceToken startId " + startId + + " is last, but have " + r.deliveredStarts.size() + + " remaining args"); + } + } + synchronized (r.stats.getBatteryStats()) { r.stats.stopRunningLocked(); r.startRequested = false; + r.callStart = false; } final long origId = Binder.clearCallingIdentity(); bringDownServiceLocked(r, false); @@ -10674,7 +10789,7 @@ public final class ActivityManagerService extends ActivityManagerNative implemen } } - public void serviceDoneExecuting(IBinder token) { + public void serviceDoneExecuting(IBinder token, int type, int startId, int res) { synchronized(this) { if (!(token instanceof ServiceRecord)) { throw new IllegalArgumentException("Invalid service token"); @@ -10692,6 +10807,51 @@ public final class ActivityManagerService extends ActivityManagerNative implemen return; } + if (type == 1) { + // This is a call from a service start... take care of + // book-keeping. + r.callStart = true; + switch (res) { + case Service.START_STICKY_COMPATIBILITY: + case Service.START_STICKY: { + // We are done with the associated start arguments. + r.findDeliveredStart(startId, true); + // Don't stop if killed. + r.stopIfKilled = false; + break; + } + case Service.START_NOT_STICKY: { + // We are done with the associated start arguments. + r.findDeliveredStart(startId, true); + if (r.lastStartId == startId) { + // There is no more work, and this service + // doesn't want to hang around if killed. + r.stopIfKilled = true; + } + break; + } + case Service.START_REDELIVER_INTENT: { + // We'll keep this item until they explicitly + // call stop for it, but keep track of the fact + // that it was delivered. + ServiceRecord.StartItem si = r.findDeliveredStart(startId, false); + if (si != null) { + si.deliveryCount = 0; + si.doneExecutingCount++; + // Don't stop if killed. + r.stopIfKilled = true; + } + break; + } + default: + throw new IllegalArgumentException( + "Unknown service start result: " + res); + } + if (res == Service.START_STICKY_COMPATIBILITY) { + r.callStart = false; + } + } + final long origId = Binder.clearCallingIdentity(); serviceDoneExecutingLocked(r, inStopping); Binder.restoreCallingIdentity(origId); diff --git a/services/java/com/android/server/am/ServiceRecord.java b/services/java/com/android/server/am/ServiceRecord.java index 9318a7223b20..afbf9c70bf35 100644 --- a/services/java/com/android/server/am/ServiceRecord.java +++ b/services/java/com/android/server/am/ServiceRecord.java @@ -64,7 +64,28 @@ class ServiceRecord extends Binder { final HashMap connections = new HashMap(); // IBinder -> ConnectionRecord of all bound clients - final List startArgs = new ArrayList(); + + // Maximum number of delivery attempts before giving up. + static final int MAX_DELIVERY_COUNT = 3; + + // Maximum number of times it can fail during execution before giving up. + static final int MAX_DONE_EXECUTING_COUNT = 6; + + static class StartItem { + final int id; + final Intent intent; + long deliveredTime; + int deliveryCount; + int doneExecutingCount; + + StartItem(int _id, Intent _intent) { + id = _id; + intent = _intent; + } + } + final ArrayList deliveredStarts = new ArrayList(); + // start() arguments which been delivered. + final ArrayList pendingStarts = new ArrayList(); // start() arguments that haven't yet been delivered. ProcessRecord app; // where this service is running or null. @@ -73,6 +94,8 @@ class ServiceRecord extends Binder { Notification foregroundNoti; // Notification record of foreground state. long lastActivity; // last time there was some activity on the service. boolean startRequested; // someone explicitly called start? + boolean stopIfKilled; // last onStart() said to stop if service killed? + boolean callStart; // last onStart() has asked to alway be called on restart. int lastStartId; // identifier of most recent start request. int executeNesting; // number of outstanding operations keeping foreground. long executingStart; // start time of last execute request. @@ -85,6 +108,25 @@ class ServiceRecord extends Binder { String stringName; // caching of toString + void dumpStartList(PrintWriter pw, String prefix, List list, long now) { + final int N = list.size(); + for (int i=0; i 0) { + pw.print(prefix); pw.println("Pending Starts:"); + dumpStartList(pw, prefix, pendingStarts, 0); + } if (bindings.size() > 0) { Iterator it = bindings.values().iterator(); + pw.print(prefix); pw.println("Bindings:"); while (it.hasNext()) { IntentBindRecord b = it.next(); pw.print(prefix); pw.print("* IntentBindRecord{"); @@ -180,6 +233,19 @@ class ServiceRecord extends Binder { restartTime = 0; } + public StartItem findDeliveredStart(int id, boolean remove) { + final int N = deliveredStarts.size(); + for (int i=0; i