ActiveServices.java revision cd97c96734ac00a6a800724fe5d8e81ee0ee134c
1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.server.am;
18
19import java.io.FileDescriptor;
20import java.io.IOException;
21import java.io.PrintWriter;
22import java.util.ArrayList;
23import java.util.HashSet;
24import java.util.Iterator;
25import java.util.List;
26
27import android.os.Build;
28import android.os.DeadObjectException;
29import android.os.Handler;
30import android.os.Looper;
31import android.os.SystemProperties;
32import android.util.ArrayMap;
33import android.util.ArraySet;
34import com.android.internal.app.ProcessMap;
35import com.android.internal.app.ProcessStats;
36import com.android.internal.os.BatteryStatsImpl;
37import com.android.internal.os.TransferPipe;
38import com.android.server.am.ActivityManagerService.ItemMatcher;
39import com.android.server.am.ActivityManagerService.NeededUriGrants;
40
41import android.app.ActivityManager;
42import android.app.AppGlobals;
43import android.app.IApplicationThread;
44import android.app.IServiceConnection;
45import android.app.Notification;
46import android.app.PendingIntent;
47import android.app.Service;
48import android.content.ComponentName;
49import android.content.Context;
50import android.content.Intent;
51import android.content.pm.ApplicationInfo;
52import android.content.pm.PackageManager;
53import android.content.pm.ResolveInfo;
54import android.content.pm.ServiceInfo;
55import android.os.Binder;
56import android.os.IBinder;
57import android.os.Message;
58import android.os.Process;
59import android.os.RemoteException;
60import android.os.SystemClock;
61import android.os.UserHandle;
62import android.util.EventLog;
63import android.util.Slog;
64import android.util.SparseArray;
65import android.util.TimeUtils;
66
67public final class ActiveServices {
68    static final boolean DEBUG_SERVICE = ActivityManagerService.DEBUG_SERVICE;
69    static final boolean DEBUG_SERVICE_EXECUTING = ActivityManagerService.DEBUG_SERVICE_EXECUTING;
70    static final boolean DEBUG_DELAYED_SERVICE = ActivityManagerService.DEBUG_SERVICE;
71    static final boolean DEBUG_DELAYED_STARTS = DEBUG_DELAYED_SERVICE;
72    static final boolean DEBUG_MU = ActivityManagerService.DEBUG_MU;
73    static final String TAG = ActivityManagerService.TAG;
74    static final String TAG_MU = ActivityManagerService.TAG_MU;
75
76    // How long we wait for a service to finish executing.
77    static final int SERVICE_TIMEOUT = 20*1000;
78
79    // How long we wait for a service to finish executing.
80    static final int SERVICE_BACKGROUND_TIMEOUT = SERVICE_TIMEOUT * 10;
81
82    // How long a service needs to be running until restarting its process
83    // is no longer considered to be a relaunch of the service.
84    static final int SERVICE_RESTART_DURATION = 1*1000;
85
86    // How long a service needs to be running until it will start back at
87    // SERVICE_RESTART_DURATION after being killed.
88    static final int SERVICE_RESET_RUN_DURATION = 60*1000;
89
90    // Multiplying factor to increase restart duration time by, for each time
91    // a service is killed before it has run for SERVICE_RESET_RUN_DURATION.
92    static final int SERVICE_RESTART_DURATION_FACTOR = 4;
93
94    // The minimum amount of time between restarting services that we allow.
95    // That is, when multiple services are restarting, we won't allow each
96    // to restart less than this amount of time from the last one.
97    static final int SERVICE_MIN_RESTART_TIME_BETWEEN = 10*1000;
98
99    // Maximum amount of time for there to be no activity on a service before
100    // we consider it non-essential and allow its process to go on the
101    // LRU background list.
102    static final int MAX_SERVICE_INACTIVITY = 30*60*1000;
103
104    // How long we wait for a background started service to stop itself before
105    // allowing the next pending start to run.
106    static final int BG_START_TIMEOUT = 15*1000;
107
108    final ActivityManagerService mAm;
109
110    // Maximum number of services that we allow to start in the background
111    // at the same time.
112    final int mMaxStartingBackground;
113
114    final SparseArray<ServiceMap> mServiceMap = new SparseArray<ServiceMap>();
115
116    /**
117     * All currently bound service connections.  Keys are the IBinder of
118     * the client's IServiceConnection.
119     */
120    final ArrayMap<IBinder, ArrayList<ConnectionRecord>> mServiceConnections
121            = new ArrayMap<IBinder, ArrayList<ConnectionRecord>>();
122
123    /**
124     * List of services that we have been asked to start,
125     * but haven't yet been able to.  It is used to hold start requests
126     * while waiting for their corresponding application thread to get
127     * going.
128     */
129    final ArrayList<ServiceRecord> mPendingServices
130            = new ArrayList<ServiceRecord>();
131
132    /**
133     * List of services that are scheduled to restart following a crash.
134     */
135    final ArrayList<ServiceRecord> mRestartingServices
136            = new ArrayList<ServiceRecord>();
137
138    /**
139     * List of services that are in the process of being destroyed.
140     */
141    final ArrayList<ServiceRecord> mDestroyingServices
142            = new ArrayList<ServiceRecord>();
143
144    static final class DelayingProcess extends ArrayList<ServiceRecord> {
145        long timeoout;
146    }
147
148    /**
149     * Information about services for a single user.
150     */
151    class ServiceMap extends Handler {
152        final int mUserId;
153        final ArrayMap<ComponentName, ServiceRecord> mServicesByName
154                = new ArrayMap<ComponentName, ServiceRecord>();
155        final ArrayMap<Intent.FilterComparison, ServiceRecord> mServicesByIntent
156                = new ArrayMap<Intent.FilterComparison, ServiceRecord>();
157
158        final ArrayList<ServiceRecord> mDelayedStartList
159                = new ArrayList<ServiceRecord>();
160        /* XXX eventually I'd like to have this based on processes instead of services.
161         * That is, if we try to start two services in a row both running in the same
162         * process, this should be one entry in mStartingBackground for that one process
163         * that remains until all services in it are done.
164        final ArrayMap<ProcessRecord, DelayingProcess> mStartingBackgroundMap
165                = new ArrayMap<ProcessRecord, DelayingProcess>();
166        final ArrayList<DelayingProcess> mStartingProcessList
167                = new ArrayList<DelayingProcess>();
168        */
169
170        final ArrayList<ServiceRecord> mStartingBackground
171                = new ArrayList<ServiceRecord>();
172
173        static final int MSG_BG_START_TIMEOUT = 1;
174
175        ServiceMap(Looper looper, int userId) {
176            super(looper);
177            mUserId = userId;
178        }
179
180        @Override
181        public void handleMessage(Message msg) {
182            switch (msg.what) {
183                case MSG_BG_START_TIMEOUT: {
184                    synchronized (mAm) {
185                        rescheduleDelayedStarts();
186                    }
187                } break;
188            }
189        }
190
191        void ensureNotStartingBackground(ServiceRecord r) {
192            if (mStartingBackground.remove(r)) {
193                if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "No longer background starting: " + r);
194                rescheduleDelayedStarts();
195            }
196            if (mDelayedStartList.remove(r)) {
197                if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "No longer delaying start: " + r);
198            }
199        }
200
201        void rescheduleDelayedStarts() {
202            removeMessages(MSG_BG_START_TIMEOUT);
203            final long now = SystemClock.uptimeMillis();
204            for (int i=0, N=mStartingBackground.size(); i<N; i++) {
205                ServiceRecord r = mStartingBackground.get(i);
206                if (r.startingBgTimeout <= now) {
207                    Slog.i(TAG, "Waited long enough for: " + r);
208                    mStartingBackground.remove(i);
209                    N--;
210                    i--;
211                }
212            }
213            while (mDelayedStartList.size() > 0
214                    && mStartingBackground.size() < mMaxStartingBackground) {
215                ServiceRecord r = mDelayedStartList.remove(0);
216                if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "REM FR DELAY LIST (exec next): " + r);
217                if (r.pendingStarts.size() <= 0) {
218                    Slog.w(TAG, "**** NO PENDING STARTS! " + r + " startReq=" + r.startRequested
219                            + " delayedStop=" + r.delayedStop);
220                }
221                if (DEBUG_DELAYED_SERVICE) {
222                    if (mDelayedStartList.size() > 0) {
223                        Slog.v(TAG, "Remaining delayed list:");
224                        for (int i=0; i<mDelayedStartList.size(); i++) {
225                            Slog.v(TAG, "  #" + i + ": " + mDelayedStartList.get(i));
226                        }
227                    }
228                }
229                r.delayed = false;
230                startServiceInnerLocked(this, r.pendingStarts.get(0).intent, r, false, true);
231            }
232            if (mStartingBackground.size() > 0) {
233                ServiceRecord next = mStartingBackground.get(0);
234                long when = next.startingBgTimeout > now ? next.startingBgTimeout : now;
235                if (DEBUG_DELAYED_SERVICE) Slog.v(TAG, "Top bg start is " + next
236                        + ", can delay others up to " + when);
237                Message msg = obtainMessage(MSG_BG_START_TIMEOUT);
238                sendMessageAtTime(msg, when);
239            }
240            if (mStartingBackground.size() < mMaxStartingBackground) {
241                mAm.backgroundServicesFinishedLocked(mUserId);
242            }
243        }
244    }
245
246    public ActiveServices(ActivityManagerService service) {
247        mAm = service;
248        int maxBg = 0;
249        try {
250            maxBg = Integer.parseInt(SystemProperties.get("ro.config.max_starting_bg", "0"));
251        } catch(RuntimeException e) {
252        }
253        mMaxStartingBackground = maxBg > 0
254                ? maxBg : ActivityManager.isLowRamDeviceStatic() ? 1 : 8;
255    }
256
257    ServiceRecord getServiceByName(ComponentName name, int callingUser) {
258        // TODO: Deal with global services
259        if (DEBUG_MU)
260            Slog.v(TAG_MU, "getServiceByName(" + name + "), callingUser = " + callingUser);
261        return getServiceMap(callingUser).mServicesByName.get(name);
262    }
263
264    boolean hasBackgroundServices(int callingUser) {
265        ServiceMap smap = mServiceMap.get(callingUser);
266        return smap != null ? smap.mStartingBackground.size() >= mMaxStartingBackground : false;
267    }
268
269    private ServiceMap getServiceMap(int callingUser) {
270        ServiceMap smap = mServiceMap.get(callingUser);
271        if (smap == null) {
272            smap = new ServiceMap(mAm.mHandler.getLooper(), callingUser);
273            mServiceMap.put(callingUser, smap);
274        }
275        return smap;
276    }
277
278    ArrayMap<ComponentName, ServiceRecord> getServices(int callingUser) {
279        return getServiceMap(callingUser).mServicesByName;
280    }
281
282    ComponentName startServiceLocked(IApplicationThread caller,
283            Intent service, String resolvedType,
284            int callingPid, int callingUid, int userId) {
285        if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "startService: " + service
286                + " type=" + resolvedType + " args=" + service.getExtras());
287
288        final boolean callerFg;
289        if (caller != null) {
290            final ProcessRecord callerApp = mAm.getRecordForAppLocked(caller);
291            if (callerApp == null) {
292                throw new SecurityException(
293                        "Unable to find app for caller " + caller
294                        + " (pid=" + Binder.getCallingPid()
295                        + ") when starting service " + service);
296            }
297            callerFg = callerApp.setSchedGroup != Process.THREAD_GROUP_BG_NONINTERACTIVE;
298        } else {
299            callerFg = true;
300        }
301
302
303        ServiceLookupResult res =
304            retrieveServiceLocked(service, resolvedType,
305                    callingPid, callingUid, userId, true, callerFg);
306        if (res == null) {
307            return null;
308        }
309        if (res.record == null) {
310            return new ComponentName("!", res.permission != null
311                    ? res.permission : "private to package");
312        }
313
314        ServiceRecord r = res.record;
315
316        if (!mAm.getUserManagerLocked().exists(r.userId)) {
317            Slog.d(TAG, "Trying to start service with non-existent user! " + r.userId);
318            return null;
319        }
320
321        NeededUriGrants neededGrants = mAm.checkGrantUriPermissionFromIntentLocked(
322                callingUid, r.packageName, service, service.getFlags(), null, r.userId);
323        if (unscheduleServiceRestartLocked(r, callingUid, false)) {
324            if (DEBUG_SERVICE) Slog.v(TAG, "START SERVICE WHILE RESTART PENDING: " + r);
325        }
326        r.lastActivity = SystemClock.uptimeMillis();
327        r.startRequested = true;
328        r.delayedStop = false;
329        r.pendingStarts.add(new ServiceRecord.StartItem(r, false, r.makeNextStartId(),
330                service, neededGrants));
331
332        final ServiceMap smap = getServiceMap(r.userId);
333        boolean addToStarting = false;
334        if (!callerFg && r.app == null && mAm.mStartedUsers.get(r.userId) != null) {
335            ProcessRecord proc = mAm.getProcessRecordLocked(r.processName, r.appInfo.uid, false);
336            if (proc == null || proc.curProcState > ActivityManager.PROCESS_STATE_RECEIVER) {
337                // If this is not coming from a foreground caller, then we may want
338                // to delay the start if there are already other background services
339                // that are starting.  This is to avoid process start spam when lots
340                // of applications are all handling things like connectivity broadcasts.
341                // We only do this for cached processes, because otherwise an application
342                // can have assumptions about calling startService() for a service to run
343                // in its own process, and for that process to not be killed before the
344                // service is started.  This is especially the case for receivers, which
345                // may start a service in onReceive() to do some additional work and have
346                // initialized some global state as part of that.
347                if (DEBUG_DELAYED_SERVICE) Slog.v(TAG, "Potential start delay of " + r + " in "
348                        + proc);
349                if (r.delayed) {
350                    // This service is already scheduled for a delayed start; just leave
351                    // it still waiting.
352                    if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "Continuing to delay: " + r);
353                    return r.name;
354                }
355                if (smap.mStartingBackground.size() >= mMaxStartingBackground) {
356                    // Something else is starting, delay!
357                    Slog.i(TAG, "Delaying start of: " + r);
358                    smap.mDelayedStartList.add(r);
359                    r.delayed = true;
360                    return r.name;
361                }
362                if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "Not delaying: " + r);
363                addToStarting = true;
364            } else if (proc.curProcState >= ActivityManager.PROCESS_STATE_SERVICE) {
365                // We slightly loosen when we will enqueue this new service as a background
366                // starting service we are waiting for, to also include processes that are
367                // currently running other services or receivers.
368                addToStarting = true;
369                if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "Not delaying, but counting as bg: " + r);
370            } else if (DEBUG_DELAYED_STARTS) {
371                StringBuilder sb = new StringBuilder(128);
372                sb.append("Not potential delay (state=").append(proc.curProcState)
373                        .append(' ').append(proc.adjType);
374                String reason = proc.makeAdjReason();
375                if (reason != null) {
376                    sb.append(' ');
377                    sb.append(reason);
378                }
379                sb.append("): ");
380                sb.append(r.toString());
381                Slog.v(TAG, sb.toString());
382            }
383        } else if (DEBUG_DELAYED_STARTS) {
384            if (callerFg) {
385                Slog.v(TAG, "Not potential delay (callerFg=" + callerFg + " uid="
386                        + callingUid + " pid=" + callingPid + "): " + r);
387            } else if (r.app != null) {
388                Slog.v(TAG, "Not potential delay (cur app=" + r.app + "): " + r);
389            } else {
390                Slog.v(TAG, "Not potential delay (user " + r.userId + " not started): " + r);
391            }
392        }
393
394        return startServiceInnerLocked(smap, service, r, callerFg, addToStarting);
395    }
396
397    ComponentName startServiceInnerLocked(ServiceMap smap, Intent service,
398            ServiceRecord r, boolean callerFg, boolean addToStarting) {
399        ProcessStats.ServiceState stracker = r.getTracker();
400        if (stracker != null) {
401            stracker.setStarted(true, mAm.mProcessStats.getMemFactorLocked(), r.lastActivity);
402        }
403        r.callStart = false;
404        synchronized (r.stats.getBatteryStats()) {
405            r.stats.startRunningLocked();
406        }
407        String error = bringUpServiceLocked(r, service.getFlags(), callerFg, false);
408        if (error != null) {
409            return new ComponentName("!!", error);
410        }
411
412        if (r.startRequested && addToStarting) {
413            boolean first = smap.mStartingBackground.size() == 0;
414            smap.mStartingBackground.add(r);
415            r.startingBgTimeout = SystemClock.uptimeMillis() + BG_START_TIMEOUT;
416            if (DEBUG_DELAYED_SERVICE) {
417                RuntimeException here = new RuntimeException("here");
418                here.fillInStackTrace();
419                Slog.v(TAG, "Starting background (first=" + first + "): " + r, here);
420            } else if (DEBUG_DELAYED_STARTS) {
421                Slog.v(TAG, "Starting background (first=" + first + "): " + r);
422            }
423            if (first) {
424                smap.rescheduleDelayedStarts();
425            }
426        } else if (callerFg) {
427            smap.ensureNotStartingBackground(r);
428        }
429
430        return r.name;
431    }
432
433    private void stopServiceLocked(ServiceRecord service) {
434        if (service.delayed) {
435            // If service isn't actually running, but is is being held in the
436            // delayed list, then we need to keep it started but note that it
437            // should be stopped once no longer delayed.
438            if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "Delaying stop of pending: " + service);
439            service.delayedStop = true;
440            return;
441        }
442        synchronized (service.stats.getBatteryStats()) {
443            service.stats.stopRunningLocked();
444        }
445        service.startRequested = false;
446        if (service.tracker != null) {
447            service.tracker.setStarted(false, mAm.mProcessStats.getMemFactorLocked(),
448                    SystemClock.uptimeMillis());
449        }
450        service.callStart = false;
451        bringDownServiceIfNeededLocked(service, false, false);
452    }
453
454    int stopServiceLocked(IApplicationThread caller, Intent service,
455            String resolvedType, int userId) {
456        if (DEBUG_SERVICE) Slog.v(TAG, "stopService: " + service
457                + " type=" + resolvedType);
458
459        final ProcessRecord callerApp = mAm.getRecordForAppLocked(caller);
460        if (caller != null && callerApp == null) {
461            throw new SecurityException(
462                    "Unable to find app for caller " + caller
463                    + " (pid=" + Binder.getCallingPid()
464                    + ") when stopping service " + service);
465        }
466
467        // If this service is active, make sure it is stopped.
468        ServiceLookupResult r = retrieveServiceLocked(service, resolvedType,
469                Binder.getCallingPid(), Binder.getCallingUid(), userId, false, false);
470        if (r != null) {
471            if (r.record != null) {
472                final long origId = Binder.clearCallingIdentity();
473                try {
474                    stopServiceLocked(r.record);
475                } finally {
476                    Binder.restoreCallingIdentity(origId);
477                }
478                return 1;
479            }
480            return -1;
481        }
482
483        return 0;
484    }
485
486    IBinder peekServiceLocked(Intent service, String resolvedType) {
487        ServiceLookupResult r = retrieveServiceLocked(service, resolvedType,
488                Binder.getCallingPid(), Binder.getCallingUid(),
489                UserHandle.getCallingUserId(), false, false);
490
491        IBinder ret = null;
492        if (r != null) {
493            // r.record is null if findServiceLocked() failed the caller permission check
494            if (r.record == null) {
495                throw new SecurityException(
496                        "Permission Denial: Accessing service " + r.record.name
497                        + " from pid=" + Binder.getCallingPid()
498                        + ", uid=" + Binder.getCallingUid()
499                        + " requires " + r.permission);
500            }
501            IntentBindRecord ib = r.record.bindings.get(r.record.intent);
502            if (ib != null) {
503                ret = ib.binder;
504            }
505        }
506
507        return ret;
508    }
509
510    boolean stopServiceTokenLocked(ComponentName className, IBinder token,
511            int startId) {
512        if (DEBUG_SERVICE) Slog.v(TAG, "stopServiceToken: " + className
513                + " " + token + " startId=" + startId);
514        ServiceRecord r = findServiceLocked(className, token, UserHandle.getCallingUserId());
515        if (r != null) {
516            if (startId >= 0) {
517                // Asked to only stop if done with all work.  Note that
518                // to avoid leaks, we will take this as dropping all
519                // start items up to and including this one.
520                ServiceRecord.StartItem si = r.findDeliveredStart(startId, false);
521                if (si != null) {
522                    while (r.deliveredStarts.size() > 0) {
523                        ServiceRecord.StartItem cur = r.deliveredStarts.remove(0);
524                        cur.removeUriPermissionsLocked();
525                        if (cur == si) {
526                            break;
527                        }
528                    }
529                }
530
531                if (r.getLastStartId() != startId) {
532                    return false;
533                }
534
535                if (r.deliveredStarts.size() > 0) {
536                    Slog.w(TAG, "stopServiceToken startId " + startId
537                            + " is last, but have " + r.deliveredStarts.size()
538                            + " remaining args");
539                }
540            }
541
542            synchronized (r.stats.getBatteryStats()) {
543                r.stats.stopRunningLocked();
544            }
545            r.startRequested = false;
546            if (r.tracker != null) {
547                r.tracker.setStarted(false, mAm.mProcessStats.getMemFactorLocked(),
548                        SystemClock.uptimeMillis());
549            }
550            r.callStart = false;
551            final long origId = Binder.clearCallingIdentity();
552            bringDownServiceIfNeededLocked(r, false, false);
553            Binder.restoreCallingIdentity(origId);
554            return true;
555        }
556        return false;
557    }
558
559    public void setServiceForegroundLocked(ComponentName className, IBinder token,
560            int id, Notification notification, boolean removeNotification) {
561        final int userId = UserHandle.getCallingUserId();
562        final long origId = Binder.clearCallingIdentity();
563        try {
564            ServiceRecord r = findServiceLocked(className, token, userId);
565            if (r != null) {
566                if (id != 0) {
567                    if (notification == null) {
568                        throw new IllegalArgumentException("null notification");
569                    }
570                    if (r.foregroundId != id) {
571                        r.cancelNotification();
572                        r.foregroundId = id;
573                    }
574                    notification.flags |= Notification.FLAG_FOREGROUND_SERVICE;
575                    r.foregroundNoti = notification;
576                    r.isForeground = true;
577                    r.postNotification();
578                    if (r.app != null) {
579                        updateServiceForegroundLocked(r.app, true);
580                    }
581                    getServiceMap(r.userId).ensureNotStartingBackground(r);
582                } else {
583                    if (r.isForeground) {
584                        r.isForeground = false;
585                        if (r.app != null) {
586                            mAm.updateLruProcessLocked(r.app, false, null);
587                            updateServiceForegroundLocked(r.app, true);
588                        }
589                    }
590                    if (removeNotification) {
591                        r.cancelNotification();
592                        r.foregroundId = 0;
593                        r.foregroundNoti = null;
594                    } else if (r.appInfo.targetSdkVersion >= Build.VERSION_CODES.L) {
595                        r.stripForegroundServiceFlagFromNotification();
596                    }
597                }
598            }
599        } finally {
600            Binder.restoreCallingIdentity(origId);
601        }
602    }
603
604    private void updateServiceForegroundLocked(ProcessRecord proc, boolean oomAdj) {
605        boolean anyForeground = false;
606        for (int i=proc.services.size()-1; i>=0; i--) {
607            ServiceRecord sr = proc.services.valueAt(i);
608            if (sr.isForeground) {
609                anyForeground = true;
610                break;
611            }
612        }
613        mAm.updateProcessForegroundLocked(proc, anyForeground, oomAdj);
614    }
615
616    public void updateServiceConnectionActivitiesLocked(ProcessRecord clientProc) {
617        ArraySet<ProcessRecord> updatedProcesses = null;
618        for (int i=0; i<clientProc.connections.size(); i++) {
619            final ConnectionRecord conn = clientProc.connections.valueAt(i);
620            final ProcessRecord proc = conn.binding.service.app;
621            if (proc == null || proc == clientProc) {
622                continue;
623            } else if (updatedProcesses == null) {
624                updatedProcesses = new ArraySet<>();
625            } else if (updatedProcesses.contains(proc)) {
626                continue;
627            }
628            updatedProcesses.add(proc);
629            updateServiceClientActivitiesLocked(proc, null, false);
630        }
631    }
632
633    private boolean updateServiceClientActivitiesLocked(ProcessRecord proc,
634            ConnectionRecord modCr, boolean updateLru) {
635        if (modCr != null && modCr.binding.client != null) {
636            if (modCr.binding.client.activities.size() <= 0) {
637                // This connection is from a client without activities, so adding
638                // and removing is not interesting.
639                return false;
640            }
641        }
642
643        boolean anyClientActivities = false;
644        for (int i=proc.services.size()-1; i>=0 && !anyClientActivities; i--) {
645            ServiceRecord sr = proc.services.valueAt(i);
646            for (int conni=sr.connections.size()-1; conni>=0 && !anyClientActivities; conni--) {
647                ArrayList<ConnectionRecord> clist = sr.connections.valueAt(conni);
648                for (int cri=clist.size()-1; cri>=0; cri--) {
649                    ConnectionRecord cr = clist.get(cri);
650                    if (cr.binding.client == null || cr.binding.client == proc) {
651                        // Binding to ourself is not interesting.
652                        continue;
653                    }
654                    if (cr.binding.client.activities.size() > 0) {
655                        anyClientActivities = true;
656                        break;
657                    }
658                }
659            }
660        }
661        if (anyClientActivities != proc.hasClientActivities) {
662            proc.hasClientActivities = anyClientActivities;
663            if (updateLru) {
664                mAm.updateLruProcessLocked(proc, anyClientActivities, null);
665            }
666            return true;
667        }
668        return false;
669    }
670
671    int bindServiceLocked(IApplicationThread caller, IBinder token,
672            Intent service, String resolvedType,
673            IServiceConnection connection, int flags, int userId) {
674        if (DEBUG_SERVICE) Slog.v(TAG, "bindService: " + service
675                + " type=" + resolvedType + " conn=" + connection.asBinder()
676                + " flags=0x" + Integer.toHexString(flags));
677        final ProcessRecord callerApp = mAm.getRecordForAppLocked(caller);
678        if (callerApp == null) {
679            throw new SecurityException(
680                    "Unable to find app for caller " + caller
681                    + " (pid=" + Binder.getCallingPid()
682                    + ") when binding service " + service);
683        }
684
685        ActivityRecord activity = null;
686        if (token != null) {
687            activity = ActivityRecord.isInStackLocked(token);
688            if (activity == null) {
689                Slog.w(TAG, "Binding with unknown activity: " + token);
690                return 0;
691            }
692        }
693
694        int clientLabel = 0;
695        PendingIntent clientIntent = null;
696
697        if (callerApp.info.uid == Process.SYSTEM_UID) {
698            // Hacky kind of thing -- allow system stuff to tell us
699            // what they are, so we can report this elsewhere for
700            // others to know why certain services are running.
701            try {
702                clientIntent = service.getParcelableExtra(Intent.EXTRA_CLIENT_INTENT);
703            } catch (RuntimeException e) {
704            }
705            if (clientIntent != null) {
706                clientLabel = service.getIntExtra(Intent.EXTRA_CLIENT_LABEL, 0);
707                if (clientLabel != 0) {
708                    // There are no useful extras in the intent, trash them.
709                    // System code calling with this stuff just needs to know
710                    // this will happen.
711                    service = service.cloneFilter();
712                }
713            }
714        }
715
716        if ((flags&Context.BIND_TREAT_LIKE_ACTIVITY) != 0) {
717            mAm.enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS,
718                    "BIND_TREAT_LIKE_ACTIVITY");
719        }
720
721        final boolean callerFg = callerApp.setSchedGroup != Process.THREAD_GROUP_BG_NONINTERACTIVE;
722
723        ServiceLookupResult res =
724            retrieveServiceLocked(service, resolvedType,
725                    Binder.getCallingPid(), Binder.getCallingUid(), userId, true, callerFg);
726        if (res == null) {
727            return 0;
728        }
729        if (res.record == null) {
730            return -1;
731        }
732        ServiceRecord s = res.record;
733
734        final long origId = Binder.clearCallingIdentity();
735
736        try {
737            if (unscheduleServiceRestartLocked(s, callerApp.info.uid, false)) {
738                if (DEBUG_SERVICE) Slog.v(TAG, "BIND SERVICE WHILE RESTART PENDING: "
739                        + s);
740            }
741
742            if ((flags&Context.BIND_AUTO_CREATE) != 0) {
743                s.lastActivity = SystemClock.uptimeMillis();
744                if (!s.hasAutoCreateConnections()) {
745                    // This is the first binding, let the tracker know.
746                    ProcessStats.ServiceState stracker = s.getTracker();
747                    if (stracker != null) {
748                        stracker.setBound(true, mAm.mProcessStats.getMemFactorLocked(),
749                                s.lastActivity);
750                    }
751                }
752            }
753
754            AppBindRecord b = s.retrieveAppBindingLocked(service, callerApp);
755            ConnectionRecord c = new ConnectionRecord(b, activity,
756                    connection, flags, clientLabel, clientIntent);
757
758            IBinder binder = connection.asBinder();
759            ArrayList<ConnectionRecord> clist = s.connections.get(binder);
760            if (clist == null) {
761                clist = new ArrayList<ConnectionRecord>();
762                s.connections.put(binder, clist);
763            }
764            clist.add(c);
765            b.connections.add(c);
766            if (activity != null) {
767                if (activity.connections == null) {
768                    activity.connections = new HashSet<ConnectionRecord>();
769                }
770                activity.connections.add(c);
771            }
772            b.client.connections.add(c);
773            if ((c.flags&Context.BIND_ABOVE_CLIENT) != 0) {
774                b.client.hasAboveClient = true;
775            }
776            if (s.app != null) {
777                updateServiceClientActivitiesLocked(s.app, c, true);
778            }
779            clist = mServiceConnections.get(binder);
780            if (clist == null) {
781                clist = new ArrayList<ConnectionRecord>();
782                mServiceConnections.put(binder, clist);
783            }
784            clist.add(c);
785
786            if ((flags&Context.BIND_AUTO_CREATE) != 0) {
787                s.lastActivity = SystemClock.uptimeMillis();
788                if (bringUpServiceLocked(s, service.getFlags(), callerFg, false) != null) {
789                    return 0;
790                }
791            }
792
793            if (s.app != null) {
794                if ((flags&Context.BIND_TREAT_LIKE_ACTIVITY) != 0) {
795                    s.app.treatLikeActivity = true;
796                }
797                // This could have made the service more important.
798                mAm.updateLruProcessLocked(s.app, s.app.hasClientActivities
799                        || s.app.treatLikeActivity, b.client);
800                mAm.updateOomAdjLocked(s.app);
801            }
802
803            if (DEBUG_SERVICE) Slog.v(TAG, "Bind " + s + " with " + b
804                    + ": received=" + b.intent.received
805                    + " apps=" + b.intent.apps.size()
806                    + " doRebind=" + b.intent.doRebind);
807
808            if (s.app != null && b.intent.received) {
809                // Service is already running, so we can immediately
810                // publish the connection.
811                try {
812                    c.conn.connected(s.name, b.intent.binder);
813                } catch (Exception e) {
814                    Slog.w(TAG, "Failure sending service " + s.shortName
815                            + " to connection " + c.conn.asBinder()
816                            + " (in " + c.binding.client.processName + ")", e);
817                }
818
819                // If this is the first app connected back to this binding,
820                // and the service had previously asked to be told when
821                // rebound, then do so.
822                if (b.intent.apps.size() == 1 && b.intent.doRebind) {
823                    requestServiceBindingLocked(s, b.intent, callerFg, true);
824                }
825            } else if (!b.intent.requested) {
826                requestServiceBindingLocked(s, b.intent, callerFg, false);
827            }
828
829            getServiceMap(s.userId).ensureNotStartingBackground(s);
830
831        } finally {
832            Binder.restoreCallingIdentity(origId);
833        }
834
835        return 1;
836    }
837
838    void publishServiceLocked(ServiceRecord r, Intent intent, IBinder service) {
839        final long origId = Binder.clearCallingIdentity();
840        try {
841            if (DEBUG_SERVICE) Slog.v(TAG, "PUBLISHING " + r
842                    + " " + intent + ": " + service);
843            if (r != null) {
844                Intent.FilterComparison filter
845                        = new Intent.FilterComparison(intent);
846                IntentBindRecord b = r.bindings.get(filter);
847                if (b != null && !b.received) {
848                    b.binder = service;
849                    b.requested = true;
850                    b.received = true;
851                    for (int conni=r.connections.size()-1; conni>=0; conni--) {
852                        ArrayList<ConnectionRecord> clist = r.connections.valueAt(conni);
853                        for (int i=0; i<clist.size(); i++) {
854                            ConnectionRecord c = clist.get(i);
855                            if (!filter.equals(c.binding.intent.intent)) {
856                                if (DEBUG_SERVICE) Slog.v(
857                                        TAG, "Not publishing to: " + c);
858                                if (DEBUG_SERVICE) Slog.v(
859                                        TAG, "Bound intent: " + c.binding.intent.intent);
860                                if (DEBUG_SERVICE) Slog.v(
861                                        TAG, "Published intent: " + intent);
862                                continue;
863                            }
864                            if (DEBUG_SERVICE) Slog.v(TAG, "Publishing to: " + c);
865                            try {
866                                c.conn.connected(r.name, service);
867                            } catch (Exception e) {
868                                Slog.w(TAG, "Failure sending service " + r.name +
869                                      " to connection " + c.conn.asBinder() +
870                                      " (in " + c.binding.client.processName + ")", e);
871                            }
872                        }
873                    }
874                }
875
876                serviceDoneExecutingLocked(r, mDestroyingServices.contains(r), false);
877            }
878        } finally {
879            Binder.restoreCallingIdentity(origId);
880        }
881    }
882
883    boolean unbindServiceLocked(IServiceConnection connection) {
884        IBinder binder = connection.asBinder();
885        if (DEBUG_SERVICE) Slog.v(TAG, "unbindService: conn=" + binder);
886        ArrayList<ConnectionRecord> clist = mServiceConnections.get(binder);
887        if (clist == null) {
888            Slog.w(TAG, "Unbind failed: could not find connection for "
889                  + connection.asBinder());
890            return false;
891        }
892
893        final long origId = Binder.clearCallingIdentity();
894        try {
895            while (clist.size() > 0) {
896                ConnectionRecord r = clist.get(0);
897                removeConnectionLocked(r, null, null);
898                if (clist.size() > 0 && clist.get(0) == r) {
899                    // In case it didn't get removed above, do it now.
900                    Slog.wtf(TAG, "Connection " + r + " not removed for binder " + binder);
901                    clist.remove(0);
902                }
903
904                if (r.binding.service.app != null) {
905                    // This could have made the service less important.
906                    if ((r.flags&Context.BIND_TREAT_LIKE_ACTIVITY) != 0) {
907                        r.binding.service.app.treatLikeActivity = true;
908                        mAm.updateLruProcessLocked(r.binding.service.app,
909                                r.binding.service.app.hasClientActivities
910                                || r.binding.service.app.treatLikeActivity, null);
911                    }
912                    mAm.updateOomAdjLocked(r.binding.service.app);
913                }
914            }
915        } finally {
916            Binder.restoreCallingIdentity(origId);
917        }
918
919        return true;
920    }
921
922    void unbindFinishedLocked(ServiceRecord r, Intent intent, boolean doRebind) {
923        final long origId = Binder.clearCallingIdentity();
924        try {
925            if (r != null) {
926                Intent.FilterComparison filter
927                        = new Intent.FilterComparison(intent);
928                IntentBindRecord b = r.bindings.get(filter);
929                if (DEBUG_SERVICE) Slog.v(TAG, "unbindFinished in " + r
930                        + " at " + b + ": apps="
931                        + (b != null ? b.apps.size() : 0));
932
933                boolean inDestroying = mDestroyingServices.contains(r);
934                if (b != null) {
935                    if (b.apps.size() > 0 && !inDestroying) {
936                        // Applications have already bound since the last
937                        // unbind, so just rebind right here.
938                        boolean inFg = false;
939                        for (int i=b.apps.size()-1; i>=0; i--) {
940                            ProcessRecord client = b.apps.valueAt(i).client;
941                            if (client != null && client.setSchedGroup
942                                    != Process.THREAD_GROUP_BG_NONINTERACTIVE) {
943                                inFg = true;
944                                break;
945                            }
946                        }
947                        requestServiceBindingLocked(r, b, inFg, true);
948                    } else {
949                        // Note to tell the service the next time there is
950                        // a new client.
951                        b.doRebind = true;
952                    }
953                }
954
955                serviceDoneExecutingLocked(r, inDestroying, false);
956            }
957        } finally {
958            Binder.restoreCallingIdentity(origId);
959        }
960    }
961
962    private final ServiceRecord findServiceLocked(ComponentName name,
963            IBinder token, int userId) {
964        ServiceRecord r = getServiceByName(name, userId);
965        return r == token ? r : null;
966    }
967
968    private final class ServiceLookupResult {
969        final ServiceRecord record;
970        final String permission;
971
972        ServiceLookupResult(ServiceRecord _record, String _permission) {
973            record = _record;
974            permission = _permission;
975        }
976    }
977
978    private class ServiceRestarter implements Runnable {
979        private ServiceRecord mService;
980
981        void setService(ServiceRecord service) {
982            mService = service;
983        }
984
985        public void run() {
986            synchronized(mAm) {
987                performServiceRestartLocked(mService);
988            }
989        }
990    }
991
992    private ServiceLookupResult retrieveServiceLocked(Intent service,
993            String resolvedType, int callingPid, int callingUid, int userId,
994            boolean createIfNeeded, boolean callingFromFg) {
995        ServiceRecord r = null;
996        if (DEBUG_SERVICE) Slog.v(TAG, "retrieveServiceLocked: " + service
997                + " type=" + resolvedType + " callingUid=" + callingUid);
998
999        userId = mAm.handleIncomingUser(callingPid, callingUid, userId,
1000                false, ActivityManagerService.ALLOW_NON_FULL_IN_PROFILE, "service", null);
1001
1002        ServiceMap smap = getServiceMap(userId);
1003        final ComponentName comp = service.getComponent();
1004        if (comp != null) {
1005            r = smap.mServicesByName.get(comp);
1006        }
1007        if (r == null) {
1008            Intent.FilterComparison filter = new Intent.FilterComparison(service);
1009            r = smap.mServicesByIntent.get(filter);
1010        }
1011        if (r == null) {
1012            try {
1013                ResolveInfo rInfo =
1014                    AppGlobals.getPackageManager().resolveService(
1015                                service, resolvedType,
1016                                ActivityManagerService.STOCK_PM_FLAGS, userId);
1017                ServiceInfo sInfo =
1018                    rInfo != null ? rInfo.serviceInfo : null;
1019                if (sInfo == null) {
1020                    Slog.w(TAG, "Unable to start service " + service + " U=" + userId +
1021                          ": not found");
1022                    return null;
1023                }
1024                ComponentName name = new ComponentName(
1025                        sInfo.applicationInfo.packageName, sInfo.name);
1026                if (userId > 0) {
1027                    if (mAm.isSingleton(sInfo.processName, sInfo.applicationInfo,
1028                            sInfo.name, sInfo.flags)
1029                            && mAm.isValidSingletonCall(callingUid, sInfo.applicationInfo.uid)) {
1030                        userId = 0;
1031                        smap = getServiceMap(0);
1032                    }
1033                    sInfo = new ServiceInfo(sInfo);
1034                    sInfo.applicationInfo = mAm.getAppInfoForUser(sInfo.applicationInfo, userId);
1035                }
1036                r = smap.mServicesByName.get(name);
1037                if (r == null && createIfNeeded) {
1038                    Intent.FilterComparison filter
1039                            = new Intent.FilterComparison(service.cloneFilter());
1040                    ServiceRestarter res = new ServiceRestarter();
1041                    BatteryStatsImpl.Uid.Pkg.Serv ss = null;
1042                    BatteryStatsImpl stats = mAm.mBatteryStatsService.getActiveStatistics();
1043                    synchronized (stats) {
1044                        ss = stats.getServiceStatsLocked(
1045                                sInfo.applicationInfo.uid, sInfo.packageName,
1046                                sInfo.name);
1047                    }
1048                    r = new ServiceRecord(mAm, ss, name, filter, sInfo, callingFromFg, res);
1049                    res.setService(r);
1050                    smap.mServicesByName.put(name, r);
1051                    smap.mServicesByIntent.put(filter, r);
1052
1053                    // Make sure this component isn't in the pending list.
1054                    for (int i=mPendingServices.size()-1; i>=0; i--) {
1055                        ServiceRecord pr = mPendingServices.get(i);
1056                        if (pr.serviceInfo.applicationInfo.uid == sInfo.applicationInfo.uid
1057                                && pr.name.equals(name)) {
1058                            mPendingServices.remove(i);
1059                        }
1060                    }
1061                }
1062            } catch (RemoteException ex) {
1063                // pm is in same process, this will never happen.
1064            }
1065        }
1066        if (r != null) {
1067            if (mAm.checkComponentPermission(r.permission,
1068                    callingPid, callingUid, r.appInfo.uid, r.exported)
1069                    != PackageManager.PERMISSION_GRANTED) {
1070                if (!r.exported) {
1071                    Slog.w(TAG, "Permission Denial: Accessing service " + r.name
1072                            + " from pid=" + callingPid
1073                            + ", uid=" + callingUid
1074                            + " that is not exported from uid " + r.appInfo.uid);
1075                    return new ServiceLookupResult(null, "not exported from uid "
1076                            + r.appInfo.uid);
1077                }
1078                Slog.w(TAG, "Permission Denial: Accessing service " + r.name
1079                        + " from pid=" + callingPid
1080                        + ", uid=" + callingUid
1081                        + " requires " + r.permission);
1082                return new ServiceLookupResult(null, r.permission);
1083            }
1084            if (!mAm.mIntentFirewall.checkService(r.name, service, callingUid, callingPid,
1085                    resolvedType, r.appInfo)) {
1086                return null;
1087            }
1088            return new ServiceLookupResult(r, null);
1089        }
1090        return null;
1091    }
1092
1093    private final void bumpServiceExecutingLocked(ServiceRecord r, boolean fg, String why) {
1094        if (DEBUG_SERVICE) Slog.v(TAG, ">>> EXECUTING "
1095                + why + " of " + r + " in app " + r.app);
1096        else if (DEBUG_SERVICE_EXECUTING) Slog.v(TAG, ">>> EXECUTING "
1097                + why + " of " + r.shortName);
1098        long now = SystemClock.uptimeMillis();
1099        if (r.executeNesting == 0) {
1100            r.executeFg = fg;
1101            ProcessStats.ServiceState stracker = r.getTracker();
1102            if (stracker != null) {
1103                stracker.setExecuting(true, mAm.mProcessStats.getMemFactorLocked(), now);
1104            }
1105            if (r.app != null) {
1106                r.app.executingServices.add(r);
1107                r.app.execServicesFg |= fg;
1108                if (r.app.executingServices.size() == 1) {
1109                    scheduleServiceTimeoutLocked(r.app);
1110                }
1111            }
1112        } else if (r.app != null && fg && !r.app.execServicesFg) {
1113            r.app.execServicesFg = true;
1114            scheduleServiceTimeoutLocked(r.app);
1115        }
1116        r.executeFg |= fg;
1117        r.executeNesting++;
1118        r.executingStart = now;
1119    }
1120
1121    private final boolean requestServiceBindingLocked(ServiceRecord r,
1122            IntentBindRecord i, boolean execInFg, boolean rebind) {
1123        if (r.app == null || r.app.thread == null) {
1124            // If service is not currently running, can't yet bind.
1125            return false;
1126        }
1127        if ((!i.requested || rebind) && i.apps.size() > 0) {
1128            try {
1129                bumpServiceExecutingLocked(r, execInFg, "bind");
1130                r.app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_SERVICE);
1131                r.app.thread.scheduleBindService(r, i.intent.getIntent(), rebind,
1132                        r.app.repProcState);
1133                if (!rebind) {
1134                    i.requested = true;
1135                }
1136                i.hasBound = true;
1137                i.doRebind = false;
1138            } catch (RemoteException e) {
1139                if (DEBUG_SERVICE) Slog.v(TAG, "Crashed while binding " + r);
1140                return false;
1141            }
1142        }
1143        return true;
1144    }
1145
1146    private final boolean scheduleServiceRestartLocked(ServiceRecord r,
1147            boolean allowCancel) {
1148        boolean canceled = false;
1149
1150        ServiceMap smap = getServiceMap(r.userId);
1151        if (smap.mServicesByName.get(r.name) != r) {
1152            ServiceRecord cur = smap.mServicesByName.get(r.name);
1153            Slog.wtf(TAG, "Attempting to schedule restart of " + r
1154                    + " when found in map: " + cur);
1155            return false;
1156        }
1157
1158        final long now = SystemClock.uptimeMillis();
1159
1160        if ((r.serviceInfo.applicationInfo.flags
1161                &ApplicationInfo.FLAG_PERSISTENT) == 0) {
1162            long minDuration = SERVICE_RESTART_DURATION;
1163            long resetTime = SERVICE_RESET_RUN_DURATION;
1164
1165            // Any delivered but not yet finished starts should be put back
1166            // on the pending list.
1167            final int N = r.deliveredStarts.size();
1168            if (N > 0) {
1169                for (int i=N-1; i>=0; i--) {
1170                    ServiceRecord.StartItem si = r.deliveredStarts.get(i);
1171                    si.removeUriPermissionsLocked();
1172                    if (si.intent == null) {
1173                        // We'll generate this again if needed.
1174                    } else if (!allowCancel || (si.deliveryCount < ServiceRecord.MAX_DELIVERY_COUNT
1175                            && si.doneExecutingCount < ServiceRecord.MAX_DONE_EXECUTING_COUNT)) {
1176                        r.pendingStarts.add(0, si);
1177                        long dur = SystemClock.uptimeMillis() - si.deliveredTime;
1178                        dur *= 2;
1179                        if (minDuration < dur) minDuration = dur;
1180                        if (resetTime < dur) resetTime = dur;
1181                    } else {
1182                        Slog.w(TAG, "Canceling start item " + si.intent + " in service "
1183                                + r.name);
1184                        canceled = true;
1185                    }
1186                }
1187                r.deliveredStarts.clear();
1188            }
1189
1190            r.totalRestartCount++;
1191            if (r.restartDelay == 0) {
1192                r.restartCount++;
1193                r.restartDelay = minDuration;
1194            } else {
1195                // If it has been a "reasonably long time" since the service
1196                // was started, then reset our restart duration back to
1197                // the beginning, so we don't infinitely increase the duration
1198                // on a service that just occasionally gets killed (which is
1199                // a normal case, due to process being killed to reclaim memory).
1200                if (now > (r.restartTime+resetTime)) {
1201                    r.restartCount = 1;
1202                    r.restartDelay = minDuration;
1203                } else {
1204                    r.restartDelay *= SERVICE_RESTART_DURATION_FACTOR;
1205                    if (r.restartDelay < minDuration) {
1206                        r.restartDelay = minDuration;
1207                    }
1208                }
1209            }
1210
1211            r.nextRestartTime = now + r.restartDelay;
1212
1213            // Make sure that we don't end up restarting a bunch of services
1214            // all at the same time.
1215            boolean repeat;
1216            do {
1217                repeat = false;
1218                for (int i=mRestartingServices.size()-1; i>=0; i--) {
1219                    ServiceRecord r2 = mRestartingServices.get(i);
1220                    if (r2 != r && r.nextRestartTime
1221                            >= (r2.nextRestartTime-SERVICE_MIN_RESTART_TIME_BETWEEN)
1222                            && r.nextRestartTime
1223                            < (r2.nextRestartTime+SERVICE_MIN_RESTART_TIME_BETWEEN)) {
1224                        r.nextRestartTime = r2.nextRestartTime + SERVICE_MIN_RESTART_TIME_BETWEEN;
1225                        r.restartDelay = r.nextRestartTime - now;
1226                        repeat = true;
1227                        break;
1228                    }
1229                }
1230            } while (repeat);
1231
1232        } else {
1233            // Persistent processes are immediately restarted, so there is no
1234            // reason to hold of on restarting their services.
1235            r.totalRestartCount++;
1236            r.restartCount = 0;
1237            r.restartDelay = 0;
1238            r.nextRestartTime = now;
1239        }
1240
1241        if (!mRestartingServices.contains(r)) {
1242            r.createdFromFg = false;
1243            mRestartingServices.add(r);
1244            r.makeRestarting(mAm.mProcessStats.getMemFactorLocked(), now);
1245        }
1246
1247        r.cancelNotification();
1248
1249        mAm.mHandler.removeCallbacks(r.restarter);
1250        mAm.mHandler.postAtTime(r.restarter, r.nextRestartTime);
1251        r.nextRestartTime = SystemClock.uptimeMillis() + r.restartDelay;
1252        Slog.w(TAG, "Scheduling restart of crashed service "
1253                + r.shortName + " in " + r.restartDelay + "ms");
1254        EventLog.writeEvent(EventLogTags.AM_SCHEDULE_SERVICE_RESTART,
1255                r.userId, r.shortName, r.restartDelay);
1256
1257        return canceled;
1258    }
1259
1260    final void performServiceRestartLocked(ServiceRecord r) {
1261        if (!mRestartingServices.contains(r)) {
1262            return;
1263        }
1264        bringUpServiceLocked(r, r.intent.getIntent().getFlags(), r.createdFromFg, true);
1265    }
1266
1267    private final boolean unscheduleServiceRestartLocked(ServiceRecord r, int callingUid,
1268            boolean force) {
1269        if (!force && r.restartDelay == 0) {
1270            return false;
1271        }
1272        // Remove from the restarting list; if the service is currently on the
1273        // restarting list, or the call is coming from another app, then this
1274        // service has become of much more interest so we reset the restart interval.
1275        boolean removed = mRestartingServices.remove(r);
1276        if (removed || callingUid != r.appInfo.uid) {
1277            r.resetRestartCounter();
1278        }
1279        if (removed) {
1280            clearRestartingIfNeededLocked(r);
1281        }
1282        mAm.mHandler.removeCallbacks(r.restarter);
1283        return true;
1284    }
1285
1286    private void clearRestartingIfNeededLocked(ServiceRecord r) {
1287        if (r.restartTracker != null) {
1288            // If this is the last restarting record with this tracker, then clear
1289            // the tracker's restarting state.
1290            boolean stillTracking = false;
1291            for (int i=mRestartingServices.size()-1; i>=0; i--) {
1292                if (mRestartingServices.get(i).restartTracker == r.restartTracker) {
1293                    stillTracking = true;
1294                    break;
1295                }
1296            }
1297            if (!stillTracking) {
1298                r.restartTracker.setRestarting(false, mAm.mProcessStats.getMemFactorLocked(),
1299                        SystemClock.uptimeMillis());
1300                r.restartTracker = null;
1301            }
1302        }
1303    }
1304
1305    private final String bringUpServiceLocked(ServiceRecord r,
1306            int intentFlags, boolean execInFg, boolean whileRestarting) {
1307        //Slog.i(TAG, "Bring up service:");
1308        //r.dump("  ");
1309
1310        if (r.app != null && r.app.thread != null) {
1311            sendServiceArgsLocked(r, execInFg, false);
1312            return null;
1313        }
1314
1315        if (!whileRestarting && r.restartDelay > 0) {
1316            // If waiting for a restart, then do nothing.
1317            return null;
1318        }
1319
1320        if (DEBUG_SERVICE) Slog.v(TAG, "Bringing up " + r + " " + r.intent);
1321
1322        // We are now bringing the service up, so no longer in the
1323        // restarting state.
1324        if (mRestartingServices.remove(r)) {
1325            clearRestartingIfNeededLocked(r);
1326        }
1327
1328        // Make sure this service is no longer considered delayed, we are starting it now.
1329        if (r.delayed) {
1330            if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "REM FR DELAY LIST (bring up): " + r);
1331            getServiceMap(r.userId).mDelayedStartList.remove(r);
1332            r.delayed = false;
1333        }
1334
1335        // Make sure that the user who owns this service is started.  If not,
1336        // we don't want to allow it to run.
1337        if (mAm.mStartedUsers.get(r.userId) == null) {
1338            String msg = "Unable to launch app "
1339                    + r.appInfo.packageName + "/"
1340                    + r.appInfo.uid + " for service "
1341                    + r.intent.getIntent() + ": user " + r.userId + " is stopped";
1342            Slog.w(TAG, msg);
1343            bringDownServiceLocked(r);
1344            return msg;
1345        }
1346
1347        // Service is now being launched, its package can't be stopped.
1348        try {
1349            AppGlobals.getPackageManager().setPackageStoppedState(
1350                    r.packageName, false, r.userId);
1351        } catch (RemoteException e) {
1352        } catch (IllegalArgumentException e) {
1353            Slog.w(TAG, "Failed trying to unstop package "
1354                    + r.packageName + ": " + e);
1355        }
1356
1357        final boolean isolated = (r.serviceInfo.flags&ServiceInfo.FLAG_ISOLATED_PROCESS) != 0;
1358        final String procName = r.processName;
1359        ProcessRecord app;
1360
1361        if (!isolated) {
1362            app = mAm.getProcessRecordLocked(procName, r.appInfo.uid, false);
1363            if (DEBUG_MU) Slog.v(TAG_MU, "bringUpServiceLocked: appInfo.uid=" + r.appInfo.uid
1364                        + " app=" + app);
1365            if (app != null && app.thread != null) {
1366                try {
1367                    app.addPackage(r.appInfo.packageName, r.appInfo.versionCode, mAm.mProcessStats);
1368                    realStartServiceLocked(r, app, execInFg);
1369                    return null;
1370                } catch (RemoteException e) {
1371                    Slog.w(TAG, "Exception when starting service " + r.shortName, e);
1372                }
1373
1374                // If a dead object exception was thrown -- fall through to
1375                // restart the application.
1376            }
1377        } else {
1378            // If this service runs in an isolated process, then each time
1379            // we call startProcessLocked() we will get a new isolated
1380            // process, starting another process if we are currently waiting
1381            // for a previous process to come up.  To deal with this, we store
1382            // in the service any current isolated process it is running in or
1383            // waiting to have come up.
1384            app = r.isolatedProc;
1385        }
1386
1387        // Not running -- get it started, and enqueue this service record
1388        // to be executed when the app comes up.
1389        if (app == null) {
1390            if ((app=mAm.startProcessLocked(procName, r.appInfo, true, intentFlags,
1391                    "service", r.name, false, isolated, false)) == null) {
1392                String msg = "Unable to launch app "
1393                        + r.appInfo.packageName + "/"
1394                        + r.appInfo.uid + " for service "
1395                        + r.intent.getIntent() + ": process is bad";
1396                Slog.w(TAG, msg);
1397                bringDownServiceLocked(r);
1398                return msg;
1399            }
1400            if (isolated) {
1401                r.isolatedProc = app;
1402            }
1403        }
1404
1405        if (!mPendingServices.contains(r)) {
1406            mPendingServices.add(r);
1407        }
1408
1409        if (r.delayedStop) {
1410            // Oh and hey we've already been asked to stop!
1411            r.delayedStop = false;
1412            if (r.startRequested) {
1413                if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "Applying delayed stop (in bring up): " + r);
1414                stopServiceLocked(r);
1415            }
1416        }
1417
1418        return null;
1419    }
1420
1421    private final void requestServiceBindingsLocked(ServiceRecord r, boolean execInFg) {
1422        for (int i=r.bindings.size()-1; i>=0; i--) {
1423            IntentBindRecord ibr = r.bindings.valueAt(i);
1424            if (!requestServiceBindingLocked(r, ibr, execInFg, false)) {
1425                break;
1426            }
1427        }
1428    }
1429
1430    private final void realStartServiceLocked(ServiceRecord r,
1431            ProcessRecord app, boolean execInFg) throws RemoteException {
1432        if (app.thread == null) {
1433            throw new RemoteException();
1434        }
1435        if (DEBUG_MU)
1436            Slog.v(TAG_MU, "realStartServiceLocked, ServiceRecord.uid = " + r.appInfo.uid
1437                    + ", ProcessRecord.uid = " + app.uid);
1438        r.app = app;
1439        r.restartTime = r.lastActivity = SystemClock.uptimeMillis();
1440
1441        app.services.add(r);
1442        bumpServiceExecutingLocked(r, execInFg, "create");
1443        mAm.updateLruProcessLocked(app, false, null);
1444        mAm.updateOomAdjLocked();
1445
1446        boolean created = false;
1447        try {
1448            String nameTerm;
1449            int lastPeriod = r.shortName.lastIndexOf('.');
1450            nameTerm = lastPeriod >= 0 ? r.shortName.substring(lastPeriod) : r.shortName;
1451            EventLogTags.writeAmCreateService(
1452                    r.userId, System.identityHashCode(r), nameTerm, r.app.uid, r.app.pid);
1453            synchronized (r.stats.getBatteryStats()) {
1454                r.stats.startLaunchedLocked();
1455            }
1456            mAm.ensurePackageDexOpt(r.serviceInfo.packageName);
1457            app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_SERVICE);
1458            app.thread.scheduleCreateService(r, r.serviceInfo,
1459                    mAm.compatibilityInfoForPackageLocked(r.serviceInfo.applicationInfo),
1460                    app.repProcState);
1461            r.postNotification();
1462            created = true;
1463        } catch (DeadObjectException e) {
1464            Slog.w(TAG, "Application dead when creating service " + r);
1465            mAm.appDiedLocked(app);
1466        } finally {
1467            if (!created) {
1468                app.services.remove(r);
1469                r.app = null;
1470                scheduleServiceRestartLocked(r, false);
1471            }
1472        }
1473
1474        requestServiceBindingsLocked(r, execInFg);
1475
1476        updateServiceClientActivitiesLocked(app, null, true);
1477
1478        // If the service is in the started state, and there are no
1479        // pending arguments, then fake up one so its onStartCommand() will
1480        // be called.
1481        if (r.startRequested && r.callStart && r.pendingStarts.size() == 0) {
1482            r.pendingStarts.add(new ServiceRecord.StartItem(r, false, r.makeNextStartId(),
1483                    null, null));
1484        }
1485
1486        sendServiceArgsLocked(r, execInFg, true);
1487
1488        if (r.delayed) {
1489            if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "REM FR DELAY LIST (new proc): " + r);
1490            getServiceMap(r.userId).mDelayedStartList.remove(r);
1491            r.delayed = false;
1492        }
1493
1494        if (r.delayedStop) {
1495            // Oh and hey we've already been asked to stop!
1496            r.delayedStop = false;
1497            if (r.startRequested) {
1498                if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "Applying delayed stop (from start): " + r);
1499                stopServiceLocked(r);
1500            }
1501        }
1502    }
1503
1504    private final void sendServiceArgsLocked(ServiceRecord r, boolean execInFg,
1505            boolean oomAdjusted) {
1506        final int N = r.pendingStarts.size();
1507        if (N == 0) {
1508            return;
1509        }
1510
1511        while (r.pendingStarts.size() > 0) {
1512            try {
1513                ServiceRecord.StartItem si = r.pendingStarts.remove(0);
1514                if (DEBUG_SERVICE) Slog.v(TAG, "Sending arguments to: "
1515                        + r + " " + r.intent + " args=" + si.intent);
1516                if (si.intent == null && N > 1) {
1517                    // If somehow we got a dummy null intent in the middle,
1518                    // then skip it.  DO NOT skip a null intent when it is
1519                    // the only one in the list -- this is to support the
1520                    // onStartCommand(null) case.
1521                    continue;
1522                }
1523                si.deliveredTime = SystemClock.uptimeMillis();
1524                r.deliveredStarts.add(si);
1525                si.deliveryCount++;
1526                if (si.neededGrants != null) {
1527                    mAm.grantUriPermissionUncheckedFromIntentLocked(si.neededGrants,
1528                            si.getUriPermissionsLocked());
1529                }
1530                bumpServiceExecutingLocked(r, execInFg, "start");
1531                if (!oomAdjusted) {
1532                    oomAdjusted = true;
1533                    mAm.updateOomAdjLocked(r.app);
1534                }
1535                int flags = 0;
1536                if (si.deliveryCount > 1) {
1537                    flags |= Service.START_FLAG_RETRY;
1538                }
1539                if (si.doneExecutingCount > 0) {
1540                    flags |= Service.START_FLAG_REDELIVERY;
1541                }
1542                r.app.thread.scheduleServiceArgs(r, si.taskRemoved, si.id, flags, si.intent);
1543            } catch (RemoteException e) {
1544                // Remote process gone...  we'll let the normal cleanup take
1545                // care of this.
1546                if (DEBUG_SERVICE) Slog.v(TAG, "Crashed while scheduling start: " + r);
1547                break;
1548            } catch (Exception e) {
1549                Slog.w(TAG, "Unexpected exception", e);
1550                break;
1551            }
1552        }
1553    }
1554
1555    private final boolean isServiceNeeded(ServiceRecord r, boolean knowConn, boolean hasConn) {
1556        // Are we still explicitly being asked to run?
1557        if (r.startRequested) {
1558            return true;
1559        }
1560
1561        // Is someone still bound to us keepign us running?
1562        if (!knowConn) {
1563            hasConn = r.hasAutoCreateConnections();
1564        }
1565        if (hasConn) {
1566            return true;
1567        }
1568
1569        return false;
1570    }
1571
1572    private final void bringDownServiceIfNeededLocked(ServiceRecord r, boolean knowConn,
1573            boolean hasConn) {
1574        //Slog.i(TAG, "Bring down service:");
1575        //r.dump("  ");
1576
1577        if (isServiceNeeded(r, knowConn, hasConn)) {
1578            return;
1579        }
1580
1581        // Are we in the process of launching?
1582        if (mPendingServices.contains(r)) {
1583            return;
1584        }
1585
1586        bringDownServiceLocked(r);
1587    }
1588
1589    private final void bringDownServiceLocked(ServiceRecord r) {
1590        //Slog.i(TAG, "Bring down service:");
1591        //r.dump("  ");
1592
1593        // Report to all of the connections that the service is no longer
1594        // available.
1595        for (int conni=r.connections.size()-1; conni>=0; conni--) {
1596            ArrayList<ConnectionRecord> c = r.connections.valueAt(conni);
1597            for (int i=0; i<c.size(); i++) {
1598                ConnectionRecord cr = c.get(i);
1599                // There is still a connection to the service that is
1600                // being brought down.  Mark it as dead.
1601                cr.serviceDead = true;
1602                try {
1603                    cr.conn.connected(r.name, null);
1604                } catch (Exception e) {
1605                    Slog.w(TAG, "Failure disconnecting service " + r.name +
1606                          " to connection " + c.get(i).conn.asBinder() +
1607                          " (in " + c.get(i).binding.client.processName + ")", e);
1608                }
1609            }
1610        }
1611
1612        // Tell the service that it has been unbound.
1613        if (r.app != null && r.app.thread != null) {
1614            for (int i=r.bindings.size()-1; i>=0; i--) {
1615                IntentBindRecord ibr = r.bindings.valueAt(i);
1616                if (DEBUG_SERVICE) Slog.v(TAG, "Bringing down binding " + ibr
1617                        + ": hasBound=" + ibr.hasBound);
1618                if (ibr.hasBound) {
1619                    try {
1620                        bumpServiceExecutingLocked(r, false, "bring down unbind");
1621                        mAm.updateOomAdjLocked(r.app);
1622                        ibr.hasBound = false;
1623                        r.app.thread.scheduleUnbindService(r,
1624                                ibr.intent.getIntent());
1625                    } catch (Exception e) {
1626                        Slog.w(TAG, "Exception when unbinding service "
1627                                + r.shortName, e);
1628                        serviceProcessGoneLocked(r);
1629                    }
1630                }
1631            }
1632        }
1633
1634        if (DEBUG_SERVICE) Slog.v(TAG, "Bringing down " + r + " " + r.intent);
1635        EventLogTags.writeAmDestroyService(
1636                r.userId, System.identityHashCode(r), (r.app != null) ? r.app.pid : -1);
1637
1638        final ServiceMap smap = getServiceMap(r.userId);
1639        smap.mServicesByName.remove(r.name);
1640        smap.mServicesByIntent.remove(r.intent);
1641        r.totalRestartCount = 0;
1642        unscheduleServiceRestartLocked(r, 0, true);
1643
1644        // Also make sure it is not on the pending list.
1645        for (int i=mPendingServices.size()-1; i>=0; i--) {
1646            if (mPendingServices.get(i) == r) {
1647                mPendingServices.remove(i);
1648                if (DEBUG_SERVICE) Slog.v(TAG, "Removed pending: " + r);
1649            }
1650        }
1651
1652        r.cancelNotification();
1653        r.isForeground = false;
1654        r.foregroundId = 0;
1655        r.foregroundNoti = null;
1656
1657        // Clear start entries.
1658        r.clearDeliveredStartsLocked();
1659        r.pendingStarts.clear();
1660
1661        if (r.app != null) {
1662            synchronized (r.stats.getBatteryStats()) {
1663                r.stats.stopLaunchedLocked();
1664            }
1665            r.app.services.remove(r);
1666            if (r.app.thread != null) {
1667                updateServiceForegroundLocked(r.app, false);
1668                try {
1669                    bumpServiceExecutingLocked(r, false, "destroy");
1670                    mDestroyingServices.add(r);
1671                    mAm.updateOomAdjLocked(r.app);
1672                    r.app.thread.scheduleStopService(r);
1673                } catch (Exception e) {
1674                    Slog.w(TAG, "Exception when destroying service "
1675                            + r.shortName, e);
1676                    serviceProcessGoneLocked(r);
1677                }
1678            } else {
1679                if (DEBUG_SERVICE) Slog.v(
1680                    TAG, "Removed service that has no process: " + r);
1681            }
1682        } else {
1683            if (DEBUG_SERVICE) Slog.v(
1684                TAG, "Removed service that is not running: " + r);
1685        }
1686
1687        if (r.bindings.size() > 0) {
1688            r.bindings.clear();
1689        }
1690
1691        if (r.restarter instanceof ServiceRestarter) {
1692           ((ServiceRestarter)r.restarter).setService(null);
1693        }
1694
1695        int memFactor = mAm.mProcessStats.getMemFactorLocked();
1696        long now = SystemClock.uptimeMillis();
1697        if (r.tracker != null) {
1698            r.tracker.setStarted(false, memFactor, now);
1699            r.tracker.setBound(false, memFactor, now);
1700            if (r.executeNesting == 0) {
1701                r.tracker.clearCurrentOwner(r, false);
1702                r.tracker = null;
1703            }
1704        }
1705
1706        smap.ensureNotStartingBackground(r);
1707    }
1708
1709    void removeConnectionLocked(
1710        ConnectionRecord c, ProcessRecord skipApp, ActivityRecord skipAct) {
1711        IBinder binder = c.conn.asBinder();
1712        AppBindRecord b = c.binding;
1713        ServiceRecord s = b.service;
1714        ArrayList<ConnectionRecord> clist = s.connections.get(binder);
1715        if (clist != null) {
1716            clist.remove(c);
1717            if (clist.size() == 0) {
1718                s.connections.remove(binder);
1719            }
1720        }
1721        b.connections.remove(c);
1722        if (c.activity != null && c.activity != skipAct) {
1723            if (c.activity.connections != null) {
1724                c.activity.connections.remove(c);
1725            }
1726        }
1727        if (b.client != skipApp) {
1728            b.client.connections.remove(c);
1729            if ((c.flags&Context.BIND_ABOVE_CLIENT) != 0) {
1730                b.client.updateHasAboveClientLocked();
1731            }
1732            if (s.app != null) {
1733                updateServiceClientActivitiesLocked(s.app, c, true);
1734            }
1735        }
1736        clist = mServiceConnections.get(binder);
1737        if (clist != null) {
1738            clist.remove(c);
1739            if (clist.size() == 0) {
1740                mServiceConnections.remove(binder);
1741            }
1742        }
1743
1744        if (b.connections.size() == 0) {
1745            b.intent.apps.remove(b.client);
1746        }
1747
1748        if (!c.serviceDead) {
1749            if (DEBUG_SERVICE) Slog.v(TAG, "Disconnecting binding " + b.intent
1750                    + ": shouldUnbind=" + b.intent.hasBound);
1751            if (s.app != null && s.app.thread != null && b.intent.apps.size() == 0
1752                    && b.intent.hasBound) {
1753                try {
1754                    bumpServiceExecutingLocked(s, false, "unbind");
1755                    if (b.client != s.app && (c.flags&Context.BIND_WAIVE_PRIORITY) == 0
1756                            && s.app.setProcState <= ActivityManager.PROCESS_STATE_RECEIVER) {
1757                        // If this service's process is not already in the cached list,
1758                        // then update it in the LRU list here because this may be causing
1759                        // it to go down there and we want it to start out near the top.
1760                        mAm.updateLruProcessLocked(s.app, false, null);
1761                    }
1762                    mAm.updateOomAdjLocked(s.app);
1763                    b.intent.hasBound = false;
1764                    // Assume the client doesn't want to know about a rebind;
1765                    // we will deal with that later if it asks for one.
1766                    b.intent.doRebind = false;
1767                    s.app.thread.scheduleUnbindService(s, b.intent.intent.getIntent());
1768                } catch (Exception e) {
1769                    Slog.w(TAG, "Exception when unbinding service " + s.shortName, e);
1770                    serviceProcessGoneLocked(s);
1771                }
1772            }
1773
1774            if ((c.flags&Context.BIND_AUTO_CREATE) != 0) {
1775                boolean hasAutoCreate = s.hasAutoCreateConnections();
1776                if (!hasAutoCreate) {
1777                    if (s.tracker != null) {
1778                        s.tracker.setBound(false, mAm.mProcessStats.getMemFactorLocked(),
1779                                SystemClock.uptimeMillis());
1780                    }
1781                }
1782                bringDownServiceIfNeededLocked(s, true, hasAutoCreate);
1783            }
1784        }
1785    }
1786
1787    void serviceDoneExecutingLocked(ServiceRecord r, int type, int startId, int res) {
1788        boolean inDestroying = mDestroyingServices.contains(r);
1789        if (r != null) {
1790            if (type == 1) {
1791                // This is a call from a service start...  take care of
1792                // book-keeping.
1793                r.callStart = true;
1794                switch (res) {
1795                    case Service.START_STICKY_COMPATIBILITY:
1796                    case Service.START_STICKY: {
1797                        // We are done with the associated start arguments.
1798                        r.findDeliveredStart(startId, true);
1799                        // Don't stop if killed.
1800                        r.stopIfKilled = false;
1801                        break;
1802                    }
1803                    case Service.START_NOT_STICKY: {
1804                        // We are done with the associated start arguments.
1805                        r.findDeliveredStart(startId, true);
1806                        if (r.getLastStartId() == startId) {
1807                            // There is no more work, and this service
1808                            // doesn't want to hang around if killed.
1809                            r.stopIfKilled = true;
1810                        }
1811                        break;
1812                    }
1813                    case Service.START_REDELIVER_INTENT: {
1814                        // We'll keep this item until they explicitly
1815                        // call stop for it, but keep track of the fact
1816                        // that it was delivered.
1817                        ServiceRecord.StartItem si = r.findDeliveredStart(startId, false);
1818                        if (si != null) {
1819                            si.deliveryCount = 0;
1820                            si.doneExecutingCount++;
1821                            // Don't stop if killed.
1822                            r.stopIfKilled = true;
1823                        }
1824                        break;
1825                    }
1826                    case Service.START_TASK_REMOVED_COMPLETE: {
1827                        // Special processing for onTaskRemoved().  Don't
1828                        // impact normal onStartCommand() processing.
1829                        r.findDeliveredStart(startId, true);
1830                        break;
1831                    }
1832                    default:
1833                        throw new IllegalArgumentException(
1834                                "Unknown service start result: " + res);
1835                }
1836                if (res == Service.START_STICKY_COMPATIBILITY) {
1837                    r.callStart = false;
1838                }
1839            }
1840            final long origId = Binder.clearCallingIdentity();
1841            serviceDoneExecutingLocked(r, inDestroying, inDestroying);
1842            Binder.restoreCallingIdentity(origId);
1843        } else {
1844            Slog.w(TAG, "Done executing unknown service from pid "
1845                    + Binder.getCallingPid());
1846        }
1847    }
1848
1849    private void serviceProcessGoneLocked(ServiceRecord r) {
1850        if (r.tracker != null) {
1851            int memFactor = mAm.mProcessStats.getMemFactorLocked();
1852            long now = SystemClock.uptimeMillis();
1853            r.tracker.setExecuting(false, memFactor, now);
1854            r.tracker.setBound(false, memFactor, now);
1855            r.tracker.setStarted(false, memFactor, now);
1856        }
1857        serviceDoneExecutingLocked(r, true, true);
1858    }
1859
1860    private void serviceDoneExecutingLocked(ServiceRecord r, boolean inDestroying,
1861            boolean finishing) {
1862        if (DEBUG_SERVICE) Slog.v(TAG, "<<< DONE EXECUTING " + r
1863                + ": nesting=" + r.executeNesting
1864                + ", inDestroying=" + inDestroying + ", app=" + r.app);
1865        else if (DEBUG_SERVICE_EXECUTING) Slog.v(TAG, "<<< DONE EXECUTING " + r.shortName);
1866        r.executeNesting--;
1867        if (r.executeNesting <= 0) {
1868            if (r.app != null) {
1869                if (DEBUG_SERVICE) Slog.v(TAG,
1870                        "Nesting at 0 of " + r.shortName);
1871                r.app.execServicesFg = false;
1872                r.app.executingServices.remove(r);
1873                if (r.app.executingServices.size() == 0) {
1874                    if (DEBUG_SERVICE || DEBUG_SERVICE_EXECUTING) Slog.v(TAG,
1875                            "No more executingServices of " + r.shortName);
1876                    mAm.mHandler.removeMessages(ActivityManagerService.SERVICE_TIMEOUT_MSG, r.app);
1877                } else if (r.executeFg) {
1878                    // Need to re-evaluate whether the app still needs to be in the foreground.
1879                    for (int i=r.app.executingServices.size()-1; i>=0; i--) {
1880                        if (r.app.executingServices.valueAt(i).executeFg) {
1881                            r.app.execServicesFg = true;
1882                            break;
1883                        }
1884                    }
1885                }
1886                if (inDestroying) {
1887                    if (DEBUG_SERVICE) Slog.v(TAG,
1888                            "doneExecuting remove destroying " + r);
1889                    mDestroyingServices.remove(r);
1890                    r.bindings.clear();
1891                }
1892                mAm.updateOomAdjLocked(r.app);
1893            }
1894            r.executeFg = false;
1895            if (r.tracker != null) {
1896                r.tracker.setExecuting(false, mAm.mProcessStats.getMemFactorLocked(),
1897                        SystemClock.uptimeMillis());
1898                if (finishing) {
1899                    r.tracker.clearCurrentOwner(r, false);
1900                    r.tracker = null;
1901                }
1902            }
1903            if (finishing) {
1904                if (r.app != null && !r.app.persistent) {
1905                    r.app.services.remove(r);
1906                }
1907                r.app = null;
1908            }
1909        }
1910    }
1911
1912    boolean attachApplicationLocked(ProcessRecord proc, String processName)
1913            throws RemoteException {
1914        boolean didSomething = false;
1915        // Collect any services that are waiting for this process to come up.
1916        if (mPendingServices.size() > 0) {
1917            ServiceRecord sr = null;
1918            try {
1919                for (int i=0; i<mPendingServices.size(); i++) {
1920                    sr = mPendingServices.get(i);
1921                    if (proc != sr.isolatedProc && (proc.uid != sr.appInfo.uid
1922                            || !processName.equals(sr.processName))) {
1923                        continue;
1924                    }
1925
1926                    mPendingServices.remove(i);
1927                    i--;
1928                    proc.addPackage(sr.appInfo.packageName, sr.appInfo.versionCode,
1929                            mAm.mProcessStats);
1930                    realStartServiceLocked(sr, proc, sr.createdFromFg);
1931                    didSomething = true;
1932                }
1933            } catch (RemoteException e) {
1934                Slog.w(TAG, "Exception in new application when starting service "
1935                        + sr.shortName, e);
1936                throw e;
1937            }
1938        }
1939        // Also, if there are any services that are waiting to restart and
1940        // would run in this process, now is a good time to start them.  It would
1941        // be weird to bring up the process but arbitrarily not let the services
1942        // run at this point just because their restart time hasn't come up.
1943        if (mRestartingServices.size() > 0) {
1944            ServiceRecord sr = null;
1945            for (int i=0; i<mRestartingServices.size(); i++) {
1946                sr = mRestartingServices.get(i);
1947                if (proc != sr.isolatedProc && (proc.uid != sr.appInfo.uid
1948                        || !processName.equals(sr.processName))) {
1949                    continue;
1950                }
1951                mAm.mHandler.removeCallbacks(sr.restarter);
1952                mAm.mHandler.post(sr.restarter);
1953            }
1954        }
1955        return didSomething;
1956    }
1957
1958    void processStartTimedOutLocked(ProcessRecord proc) {
1959        for (int i=0; i<mPendingServices.size(); i++) {
1960            ServiceRecord sr = mPendingServices.get(i);
1961            if ((proc.uid == sr.appInfo.uid
1962                    && proc.processName.equals(sr.processName))
1963                    || sr.isolatedProc == proc) {
1964                Slog.w(TAG, "Forcing bringing down service: " + sr);
1965                sr.isolatedProc = null;
1966                mPendingServices.remove(i);
1967                i--;
1968                bringDownServiceLocked(sr);
1969            }
1970        }
1971    }
1972
1973    private boolean collectForceStopServicesLocked(String name, int userId,
1974            boolean evenPersistent, boolean doit,
1975            ArrayMap<ComponentName, ServiceRecord> services,
1976            ArrayList<ServiceRecord> result) {
1977        boolean didSomething = false;
1978        for (int i=0; i<services.size(); i++) {
1979            ServiceRecord service = services.valueAt(i);
1980            if ((name == null || service.packageName.equals(name))
1981                    && (service.app == null || evenPersistent || !service.app.persistent)) {
1982                if (!doit) {
1983                    return true;
1984                }
1985                didSomething = true;
1986                Slog.i(TAG, "  Force stopping service " + service);
1987                if (service.app != null) {
1988                    service.app.removed = true;
1989                    if (!service.app.persistent) {
1990                        service.app.services.remove(service);
1991                    }
1992                }
1993                service.app = null;
1994                service.isolatedProc = null;
1995                result.add(service);
1996            }
1997        }
1998        return didSomething;
1999    }
2000
2001    boolean forceStopLocked(String name, int userId, boolean evenPersistent, boolean doit) {
2002        boolean didSomething = false;
2003        ArrayList<ServiceRecord> services = new ArrayList<ServiceRecord>();
2004        if (userId == UserHandle.USER_ALL) {
2005            for (int i=0; i<mServiceMap.size(); i++) {
2006                didSomething |= collectForceStopServicesLocked(name, userId, evenPersistent,
2007                        doit, mServiceMap.valueAt(i).mServicesByName, services);
2008                if (!doit && didSomething) {
2009                    return true;
2010                }
2011            }
2012        } else {
2013            ServiceMap smap = mServiceMap.get(userId);
2014            if (smap != null) {
2015                ArrayMap<ComponentName, ServiceRecord> items = smap.mServicesByName;
2016                didSomething = collectForceStopServicesLocked(name, userId, evenPersistent,
2017                        doit, items, services);
2018            }
2019        }
2020
2021        int N = services.size();
2022        for (int i=0; i<N; i++) {
2023            bringDownServiceLocked(services.get(i));
2024        }
2025        return didSomething;
2026    }
2027
2028    void cleanUpRemovedTaskLocked(TaskRecord tr, ComponentName component, Intent baseIntent) {
2029        ArrayList<ServiceRecord> services = new ArrayList<ServiceRecord>();
2030        ArrayMap<ComponentName, ServiceRecord> alls = getServices(tr.userId);
2031        for (int i=0; i<alls.size(); i++) {
2032            ServiceRecord sr = alls.valueAt(i);
2033            if (sr.packageName.equals(component.getPackageName())) {
2034                services.add(sr);
2035            }
2036        }
2037
2038        // Take care of any running services associated with the app.
2039        for (int i=0; i<services.size(); i++) {
2040            ServiceRecord sr = services.get(i);
2041            if (sr.startRequested) {
2042                if ((sr.serviceInfo.flags&ServiceInfo.FLAG_STOP_WITH_TASK) != 0) {
2043                    Slog.i(TAG, "Stopping service " + sr.shortName + ": remove task");
2044                    stopServiceLocked(sr);
2045                } else {
2046                    sr.pendingStarts.add(new ServiceRecord.StartItem(sr, true,
2047                            sr.makeNextStartId(), baseIntent, null));
2048                    if (sr.app != null && sr.app.thread != null) {
2049                        // We always run in the foreground, since this is called as
2050                        // part of the "remove task" UI operation.
2051                        sendServiceArgsLocked(sr, true, false);
2052                    }
2053                }
2054            }
2055        }
2056    }
2057
2058    final void killServicesLocked(ProcessRecord app, boolean allowRestart) {
2059        // Report disconnected services.
2060        if (false) {
2061            // XXX we are letting the client link to the service for
2062            // death notifications.
2063            if (app.services.size() > 0) {
2064                Iterator<ServiceRecord> it = app.services.iterator();
2065                while (it.hasNext()) {
2066                    ServiceRecord r = it.next();
2067                    for (int conni=r.connections.size()-1; conni>=0; conni--) {
2068                        ArrayList<ConnectionRecord> cl = r.connections.valueAt(conni);
2069                        for (int i=0; i<cl.size(); i++) {
2070                            ConnectionRecord c = cl.get(i);
2071                            if (c.binding.client != app) {
2072                                try {
2073                                    //c.conn.connected(r.className, null);
2074                                } catch (Exception e) {
2075                                    // todo: this should be asynchronous!
2076                                    Slog.w(TAG, "Exception thrown disconnected servce "
2077                                          + r.shortName
2078                                          + " from app " + app.processName, e);
2079                                }
2080                            }
2081                        }
2082                    }
2083                }
2084            }
2085        }
2086
2087        // First clear app state from services.
2088        for (int i=app.services.size()-1; i>=0; i--) {
2089            ServiceRecord sr = app.services.valueAt(i);
2090            synchronized (sr.stats.getBatteryStats()) {
2091                sr.stats.stopLaunchedLocked();
2092            }
2093            if (sr.app != app && sr.app != null && !sr.app.persistent) {
2094                sr.app.services.remove(sr);
2095            }
2096            sr.app = null;
2097            sr.isolatedProc = null;
2098            sr.executeNesting = 0;
2099            sr.forceClearTracker();
2100            if (mDestroyingServices.remove(sr)) {
2101                if (DEBUG_SERVICE) Slog.v(TAG, "killServices remove destroying " + sr);
2102            }
2103
2104            final int numClients = sr.bindings.size();
2105            for (int bindingi=numClients-1; bindingi>=0; bindingi--) {
2106                IntentBindRecord b = sr.bindings.valueAt(bindingi);
2107                if (DEBUG_SERVICE) Slog.v(TAG, "Killing binding " + b
2108                        + ": shouldUnbind=" + b.hasBound);
2109                b.binder = null;
2110                b.requested = b.received = b.hasBound = false;
2111                // If this binding is coming from a cached process and is asking to keep
2112                // the service created, then we'll kill the cached process as well -- we
2113                // don't want to be thrashing around restarting processes that are only
2114                // there to be cached.
2115                for (int appi=b.apps.size()-1; appi>=0; appi--) {
2116                    final ProcessRecord proc = b.apps.keyAt(appi);
2117                    // If the process is already gone, skip it.
2118                    if (proc.killedByAm || proc.thread == null) {
2119                        continue;
2120                    }
2121                    // Only do this for processes that have an auto-create binding;
2122                    // otherwise the binding can be left, because it won't cause the
2123                    // service to restart.
2124                    final AppBindRecord abind = b.apps.valueAt(appi);
2125                    boolean hasCreate = false;
2126                    for (int conni=abind.connections.size()-1; conni>=0; conni--) {
2127                        ConnectionRecord conn = abind.connections.valueAt(conni);
2128                        if ((conn.flags&(Context.BIND_AUTO_CREATE|Context.BIND_ALLOW_OOM_MANAGEMENT
2129                                |Context.BIND_WAIVE_PRIORITY)) == Context.BIND_AUTO_CREATE) {
2130                            hasCreate = true;
2131                            break;
2132                        }
2133                    }
2134                    if (!hasCreate) {
2135                        continue;
2136                    }
2137                    // XXX turned off for now until we have more time to get a better policy.
2138                    if (false && proc != null && !proc.persistent && proc.thread != null
2139                            && proc.pid != 0 && proc.pid != ActivityManagerService.MY_PID
2140                            && proc.setProcState >= ActivityManager.PROCESS_STATE_LAST_ACTIVITY) {
2141                        proc.kill("bound to service " + sr.name.flattenToShortString()
2142                                + " in dying proc " + (app != null ? app.processName : "??"), true);
2143                    }
2144                }
2145            }
2146        }
2147
2148        // Clean up any connections this application has to other services.
2149        for (int i=app.connections.size()-1; i>=0; i--) {
2150            ConnectionRecord r = app.connections.valueAt(i);
2151            removeConnectionLocked(r, app, null);
2152        }
2153        updateServiceConnectionActivitiesLocked(app);
2154        app.connections.clear();
2155
2156        ServiceMap smap = getServiceMap(app.userId);
2157
2158        // Now do remaining service cleanup.
2159        for (int i=app.services.size()-1; i>=0; i--) {
2160            ServiceRecord sr = app.services.valueAt(i);
2161
2162            // Unless the process is persistent, this process record is going away,
2163            // so make sure the service is cleaned out of it.
2164            if (!app.persistent) {
2165                app.services.removeAt(i);
2166            }
2167
2168            // Sanity check: if the service listed for the app is not one
2169            // we actually are maintaining, just let it drop.
2170            final ServiceRecord curRec = smap.mServicesByName.get(sr.name);
2171            if (curRec != sr) {
2172                if (curRec != null) {
2173                    Slog.wtf(TAG, "Service " + sr + " in process " + app
2174                            + " not same as in map: " + curRec);
2175                }
2176                continue;
2177            }
2178
2179            // Any services running in the application may need to be placed
2180            // back in the pending list.
2181            if (allowRestart && sr.crashCount >= 2 && (sr.serviceInfo.applicationInfo.flags
2182                    &ApplicationInfo.FLAG_PERSISTENT) == 0) {
2183                Slog.w(TAG, "Service crashed " + sr.crashCount
2184                        + " times, stopping: " + sr);
2185                EventLog.writeEvent(EventLogTags.AM_SERVICE_CRASHED_TOO_MUCH,
2186                        sr.userId, sr.crashCount, sr.shortName, app.pid);
2187                bringDownServiceLocked(sr);
2188            } else if (!allowRestart) {
2189                bringDownServiceLocked(sr);
2190            } else {
2191                boolean canceled = scheduleServiceRestartLocked(sr, true);
2192
2193                // Should the service remain running?  Note that in the
2194                // extreme case of so many attempts to deliver a command
2195                // that it failed we also will stop it here.
2196                if (sr.startRequested && (sr.stopIfKilled || canceled)) {
2197                    if (sr.pendingStarts.size() == 0) {
2198                        sr.startRequested = false;
2199                        if (sr.tracker != null) {
2200                            sr.tracker.setStarted(false, mAm.mProcessStats.getMemFactorLocked(),
2201                                    SystemClock.uptimeMillis());
2202                        }
2203                        if (!sr.hasAutoCreateConnections()) {
2204                            // Whoops, no reason to restart!
2205                            bringDownServiceLocked(sr);
2206                        }
2207                    }
2208                }
2209            }
2210        }
2211
2212        if (!allowRestart) {
2213            app.services.clear();
2214
2215            // Make sure there are no more restarting services for this process.
2216            for (int i=mRestartingServices.size()-1; i>=0; i--) {
2217                ServiceRecord r = mRestartingServices.get(i);
2218                if (r.processName.equals(app.processName) &&
2219                        r.serviceInfo.applicationInfo.uid == app.info.uid) {
2220                    mRestartingServices.remove(i);
2221                    clearRestartingIfNeededLocked(r);
2222                }
2223            }
2224            for (int i=mPendingServices.size()-1; i>=0; i--) {
2225                ServiceRecord r = mPendingServices.get(i);
2226                if (r.processName.equals(app.processName) &&
2227                        r.serviceInfo.applicationInfo.uid == app.info.uid) {
2228                    mPendingServices.remove(i);
2229                }
2230            }
2231        }
2232
2233        // Make sure we have no more records on the stopping list.
2234        int i = mDestroyingServices.size();
2235        while (i > 0) {
2236            i--;
2237            ServiceRecord sr = mDestroyingServices.get(i);
2238            if (sr.app == app) {
2239                sr.forceClearTracker();
2240                mDestroyingServices.remove(i);
2241                if (DEBUG_SERVICE) Slog.v(TAG, "killServices remove destroying " + sr);
2242            }
2243        }
2244
2245        app.executingServices.clear();
2246    }
2247
2248    ActivityManager.RunningServiceInfo makeRunningServiceInfoLocked(ServiceRecord r) {
2249        ActivityManager.RunningServiceInfo info =
2250            new ActivityManager.RunningServiceInfo();
2251        info.service = r.name;
2252        if (r.app != null) {
2253            info.pid = r.app.pid;
2254        }
2255        info.uid = r.appInfo.uid;
2256        info.process = r.processName;
2257        info.foreground = r.isForeground;
2258        info.activeSince = r.createTime;
2259        info.started = r.startRequested;
2260        info.clientCount = r.connections.size();
2261        info.crashCount = r.crashCount;
2262        info.lastActivityTime = r.lastActivity;
2263        if (r.isForeground) {
2264            info.flags |= ActivityManager.RunningServiceInfo.FLAG_FOREGROUND;
2265        }
2266        if (r.startRequested) {
2267            info.flags |= ActivityManager.RunningServiceInfo.FLAG_STARTED;
2268        }
2269        if (r.app != null && r.app.pid == ActivityManagerService.MY_PID) {
2270            info.flags |= ActivityManager.RunningServiceInfo.FLAG_SYSTEM_PROCESS;
2271        }
2272        if (r.app != null && r.app.persistent) {
2273            info.flags |= ActivityManager.RunningServiceInfo.FLAG_PERSISTENT_PROCESS;
2274        }
2275
2276        for (int conni=r.connections.size()-1; conni>=0; conni--) {
2277            ArrayList<ConnectionRecord> connl = r.connections.valueAt(conni);
2278            for (int i=0; i<connl.size(); i++) {
2279                ConnectionRecord conn = connl.get(i);
2280                if (conn.clientLabel != 0) {
2281                    info.clientPackage = conn.binding.client.info.packageName;
2282                    info.clientLabel = conn.clientLabel;
2283                    return info;
2284                }
2285            }
2286        }
2287        return info;
2288    }
2289
2290    List<ActivityManager.RunningServiceInfo> getRunningServiceInfoLocked(int maxNum,
2291            int flags) {
2292        ArrayList<ActivityManager.RunningServiceInfo> res
2293                = new ArrayList<ActivityManager.RunningServiceInfo>();
2294
2295        final int uid = Binder.getCallingUid();
2296        final long ident = Binder.clearCallingIdentity();
2297        try {
2298            if (ActivityManager.checkUidPermission(
2299                    android.Manifest.permission.INTERACT_ACROSS_USERS_FULL,
2300                    uid) == PackageManager.PERMISSION_GRANTED) {
2301                int[] users = mAm.getUsersLocked();
2302                for (int ui=0; ui<users.length && res.size() < maxNum; ui++) {
2303                    ArrayMap<ComponentName, ServiceRecord> alls = getServices(users[ui]);
2304                    for (int i=0; i<alls.size() && res.size() < maxNum; i++) {
2305                        ServiceRecord sr = alls.valueAt(i);
2306                        res.add(makeRunningServiceInfoLocked(sr));
2307                    }
2308                }
2309
2310                for (int i=0; i<mRestartingServices.size() && res.size() < maxNum; i++) {
2311                    ServiceRecord r = mRestartingServices.get(i);
2312                    ActivityManager.RunningServiceInfo info =
2313                            makeRunningServiceInfoLocked(r);
2314                    info.restarting = r.nextRestartTime;
2315                    res.add(info);
2316                }
2317            } else {
2318                int userId = UserHandle.getUserId(uid);
2319                ArrayMap<ComponentName, ServiceRecord> alls = getServices(userId);
2320                for (int i=0; i<alls.size() && res.size() < maxNum; i++) {
2321                    ServiceRecord sr = alls.valueAt(i);
2322                    res.add(makeRunningServiceInfoLocked(sr));
2323                }
2324
2325                for (int i=0; i<mRestartingServices.size() && res.size() < maxNum; i++) {
2326                    ServiceRecord r = mRestartingServices.get(i);
2327                    if (r.userId == userId) {
2328                        ActivityManager.RunningServiceInfo info =
2329                                makeRunningServiceInfoLocked(r);
2330                        info.restarting = r.nextRestartTime;
2331                        res.add(info);
2332                    }
2333                }
2334            }
2335        } finally {
2336            Binder.restoreCallingIdentity(ident);
2337        }
2338
2339        return res;
2340    }
2341
2342    public PendingIntent getRunningServiceControlPanelLocked(ComponentName name) {
2343        int userId = UserHandle.getUserId(Binder.getCallingUid());
2344        ServiceRecord r = getServiceByName(name, userId);
2345        if (r != null) {
2346            for (int conni=r.connections.size()-1; conni>=0; conni--) {
2347                ArrayList<ConnectionRecord> conn = r.connections.valueAt(conni);
2348                for (int i=0; i<conn.size(); i++) {
2349                    if (conn.get(i).clientIntent != null) {
2350                        return conn.get(i).clientIntent;
2351                    }
2352                }
2353            }
2354        }
2355        return null;
2356    }
2357
2358    void serviceTimeout(ProcessRecord proc) {
2359        String anrMessage = null;
2360
2361        synchronized(mAm) {
2362            if (proc.executingServices.size() == 0 || proc.thread == null) {
2363                return;
2364            }
2365            long maxTime = SystemClock.uptimeMillis() -
2366                    (proc.execServicesFg ? SERVICE_TIMEOUT : SERVICE_BACKGROUND_TIMEOUT);
2367            ServiceRecord timeout = null;
2368            long nextTime = 0;
2369            for (int i=proc.executingServices.size()-1; i>=0; i--) {
2370                ServiceRecord sr = proc.executingServices.valueAt(i);
2371                if (sr.executingStart < maxTime) {
2372                    timeout = sr;
2373                    break;
2374                }
2375                if (sr.executingStart > nextTime) {
2376                    nextTime = sr.executingStart;
2377                }
2378            }
2379            if (timeout != null && mAm.mLruProcesses.contains(proc)) {
2380                Slog.w(TAG, "Timeout executing service: " + timeout);
2381                anrMessage = "Executing service " + timeout.shortName;
2382            } else {
2383                Message msg = mAm.mHandler.obtainMessage(
2384                        ActivityManagerService.SERVICE_TIMEOUT_MSG);
2385                msg.obj = proc;
2386                mAm.mHandler.sendMessageAtTime(msg, proc.execServicesFg
2387                        ? (nextTime+SERVICE_TIMEOUT) : (nextTime + SERVICE_BACKGROUND_TIMEOUT));
2388            }
2389        }
2390
2391        if (anrMessage != null) {
2392            mAm.appNotResponding(proc, null, null, false, anrMessage);
2393        }
2394    }
2395
2396    void scheduleServiceTimeoutLocked(ProcessRecord proc) {
2397        if (proc.executingServices.size() == 0 || proc.thread == null) {
2398            return;
2399        }
2400        long now = SystemClock.uptimeMillis();
2401        Message msg = mAm.mHandler.obtainMessage(
2402                ActivityManagerService.SERVICE_TIMEOUT_MSG);
2403        msg.obj = proc;
2404        mAm.mHandler.sendMessageAtTime(msg,
2405                proc.execServicesFg ? (now+SERVICE_TIMEOUT) : (now+ SERVICE_BACKGROUND_TIMEOUT));
2406    }
2407
2408    /**
2409     * Prints a list of ServiceRecords (dumpsys activity services)
2410     */
2411    void dumpServicesLocked(FileDescriptor fd, PrintWriter pw, String[] args,
2412            int opti, boolean dumpAll, boolean dumpClient, String dumpPackage) {
2413        boolean needSep = false;
2414        boolean printedAnything = false;
2415
2416        ItemMatcher matcher = new ItemMatcher();
2417        matcher.build(args, opti);
2418
2419        pw.println("ACTIVITY MANAGER SERVICES (dumpsys activity services)");
2420        try {
2421            int[] users = mAm.getUsersLocked();
2422            for (int user : users) {
2423                ServiceMap smap = getServiceMap(user);
2424                boolean printed = false;
2425                if (smap.mServicesByName.size() > 0) {
2426                    long nowReal = SystemClock.elapsedRealtime();
2427                    needSep = false;
2428                    for (int si=0; si<smap.mServicesByName.size(); si++) {
2429                        ServiceRecord r = smap.mServicesByName.valueAt(si);
2430                        if (!matcher.match(r, r.name)) {
2431                            continue;
2432                        }
2433                        if (dumpPackage != null && !dumpPackage.equals(r.appInfo.packageName)) {
2434                            continue;
2435                        }
2436                        if (!printed) {
2437                            if (printedAnything) {
2438                                pw.println();
2439                            }
2440                            pw.println("  User " + user + " active services:");
2441                            printed = true;
2442                        }
2443                        printedAnything = true;
2444                        if (needSep) {
2445                            pw.println();
2446                        }
2447                        pw.print("  * ");
2448                        pw.println(r);
2449                        if (dumpAll) {
2450                            r.dump(pw, "    ");
2451                            needSep = true;
2452                        } else {
2453                            pw.print("    app=");
2454                            pw.println(r.app);
2455                            pw.print("    created=");
2456                            TimeUtils.formatDuration(r.createTime, nowReal, pw);
2457                            pw.print(" started=");
2458                            pw.print(r.startRequested);
2459                            pw.print(" connections=");
2460                            pw.println(r.connections.size());
2461                            if (r.connections.size() > 0) {
2462                                pw.println("    Connections:");
2463                                for (int conni=0; conni<r.connections.size(); conni++) {
2464                                    ArrayList<ConnectionRecord> clist = r.connections.valueAt(conni);
2465                                    for (int i = 0; i < clist.size(); i++) {
2466                                        ConnectionRecord conn = clist.get(i);
2467                                        pw.print("      ");
2468                                        pw.print(conn.binding.intent.intent.getIntent()
2469                                                .toShortString(false, false, false, false));
2470                                        pw.print(" -> ");
2471                                        ProcessRecord proc = conn.binding.client;
2472                                        pw.println(proc != null ? proc.toShortString() : "null");
2473                                    }
2474                                }
2475                            }
2476                        }
2477                        if (dumpClient && r.app != null && r.app.thread != null) {
2478                            pw.println("    Client:");
2479                            pw.flush();
2480                            try {
2481                                TransferPipe tp = new TransferPipe();
2482                                try {
2483                                    r.app.thread.dumpService(tp.getWriteFd().getFileDescriptor(),
2484                                            r, args);
2485                                    tp.setBufferPrefix("      ");
2486                                    // Short timeout, since blocking here can
2487                                    // deadlock with the application.
2488                                    tp.go(fd, 2000);
2489                                } finally {
2490                                    tp.kill();
2491                                }
2492                            } catch (IOException e) {
2493                                pw.println("      Failure while dumping the service: " + e);
2494                            } catch (RemoteException e) {
2495                                pw.println("      Got a RemoteException while dumping the service");
2496                            }
2497                            needSep = true;
2498                        }
2499                    }
2500                    needSep |= printed;
2501                }
2502                printed = false;
2503                for (int si=0, SN=smap.mDelayedStartList.size(); si<SN; si++) {
2504                    ServiceRecord r = smap.mDelayedStartList.get(si);
2505                    if (!matcher.match(r, r.name)) {
2506                        continue;
2507                    }
2508                    if (dumpPackage != null && !dumpPackage.equals(r.appInfo.packageName)) {
2509                        continue;
2510                    }
2511                    if (!printed) {
2512                        if (printedAnything) {
2513                            pw.println();
2514                        }
2515                        pw.println("  User " + user + " delayed start services:");
2516                        printed = true;
2517                    }
2518                    printedAnything = true;
2519                    pw.print("  * Delayed start "); pw.println(r);
2520                }
2521                printed = false;
2522                for (int si=0, SN=smap.mStartingBackground.size(); si<SN; si++) {
2523                    ServiceRecord r = smap.mStartingBackground.get(si);
2524                    if (!matcher.match(r, r.name)) {
2525                        continue;
2526                    }
2527                    if (dumpPackage != null && !dumpPackage.equals(r.appInfo.packageName)) {
2528                        continue;
2529                    }
2530                    if (!printed) {
2531                        if (printedAnything) {
2532                            pw.println();
2533                        }
2534                        pw.println("  User " + user + " starting in background:");
2535                        printed = true;
2536                    }
2537                    printedAnything = true;
2538                    pw.print("  * Starting bg "); pw.println(r);
2539                }
2540            }
2541        } catch (Exception e) {
2542            Slog.w(TAG, "Exception in dumpServicesLocked", e);
2543        }
2544
2545        if (mPendingServices.size() > 0) {
2546            boolean printed = false;
2547            for (int i=0; i<mPendingServices.size(); i++) {
2548                ServiceRecord r = mPendingServices.get(i);
2549                if (!matcher.match(r, r.name)) {
2550                    continue;
2551                }
2552                if (dumpPackage != null && !dumpPackage.equals(r.appInfo.packageName)) {
2553                    continue;
2554                }
2555                printedAnything = true;
2556                if (!printed) {
2557                    if (needSep) pw.println();
2558                    needSep = true;
2559                    pw.println("  Pending services:");
2560                    printed = true;
2561                }
2562                pw.print("  * Pending "); pw.println(r);
2563                r.dump(pw, "    ");
2564            }
2565            needSep = true;
2566        }
2567
2568        if (mRestartingServices.size() > 0) {
2569            boolean printed = false;
2570            for (int i=0; i<mRestartingServices.size(); i++) {
2571                ServiceRecord r = mRestartingServices.get(i);
2572                if (!matcher.match(r, r.name)) {
2573                    continue;
2574                }
2575                if (dumpPackage != null && !dumpPackage.equals(r.appInfo.packageName)) {
2576                    continue;
2577                }
2578                printedAnything = true;
2579                if (!printed) {
2580                    if (needSep) pw.println();
2581                    needSep = true;
2582                    pw.println("  Restarting services:");
2583                    printed = true;
2584                }
2585                pw.print("  * Restarting "); pw.println(r);
2586                r.dump(pw, "    ");
2587            }
2588            needSep = true;
2589        }
2590
2591        if (mDestroyingServices.size() > 0) {
2592            boolean printed = false;
2593            for (int i=0; i< mDestroyingServices.size(); i++) {
2594                ServiceRecord r = mDestroyingServices.get(i);
2595                if (!matcher.match(r, r.name)) {
2596                    continue;
2597                }
2598                if (dumpPackage != null && !dumpPackage.equals(r.appInfo.packageName)) {
2599                    continue;
2600                }
2601                printedAnything = true;
2602                if (!printed) {
2603                    if (needSep) pw.println();
2604                    needSep = true;
2605                    pw.println("  Destroying services:");
2606                    printed = true;
2607                }
2608                pw.print("  * Destroy "); pw.println(r);
2609                r.dump(pw, "    ");
2610            }
2611            needSep = true;
2612        }
2613
2614        if (dumpAll) {
2615            boolean printed = false;
2616            for (int ic=0; ic<mServiceConnections.size(); ic++) {
2617                ArrayList<ConnectionRecord> r = mServiceConnections.valueAt(ic);
2618                for (int i=0; i<r.size(); i++) {
2619                    ConnectionRecord cr = r.get(i);
2620                    if (!matcher.match(cr.binding.service, cr.binding.service.name)) {
2621                        continue;
2622                    }
2623                    if (dumpPackage != null && (cr.binding.client == null
2624                            || !dumpPackage.equals(cr.binding.client.info.packageName))) {
2625                        continue;
2626                    }
2627                    printedAnything = true;
2628                    if (!printed) {
2629                        if (needSep) pw.println();
2630                        needSep = true;
2631                        pw.println("  Connection bindings to services:");
2632                        printed = true;
2633                    }
2634                    pw.print("  * "); pw.println(cr);
2635                    cr.dump(pw, "    ");
2636                }
2637            }
2638        }
2639
2640        if (!printedAnything) {
2641            pw.println("  (nothing)");
2642        }
2643    }
2644
2645    /**
2646     * There are three ways to call this:
2647     *  - no service specified: dump all the services
2648     *  - a flattened component name that matched an existing service was specified as the
2649     *    first arg: dump that one service
2650     *  - the first arg isn't the flattened component name of an existing service:
2651     *    dump all services whose component contains the first arg as a substring
2652     */
2653    protected boolean dumpService(FileDescriptor fd, PrintWriter pw, String name, String[] args,
2654            int opti, boolean dumpAll) {
2655        ArrayList<ServiceRecord> services = new ArrayList<ServiceRecord>();
2656
2657        synchronized (mAm) {
2658            int[] users = mAm.getUsersLocked();
2659            if ("all".equals(name)) {
2660                for (int user : users) {
2661                    ServiceMap smap = mServiceMap.get(user);
2662                    if (smap == null) {
2663                        continue;
2664                    }
2665                    ArrayMap<ComponentName, ServiceRecord> alls = smap.mServicesByName;
2666                    for (int i=0; i<alls.size(); i++) {
2667                        ServiceRecord r1 = alls.valueAt(i);
2668                        services.add(r1);
2669                    }
2670                }
2671            } else {
2672                ComponentName componentName = name != null
2673                        ? ComponentName.unflattenFromString(name) : null;
2674                int objectId = 0;
2675                if (componentName == null) {
2676                    // Not a '/' separated full component name; maybe an object ID?
2677                    try {
2678                        objectId = Integer.parseInt(name, 16);
2679                        name = null;
2680                        componentName = null;
2681                    } catch (RuntimeException e) {
2682                    }
2683                }
2684
2685                for (int user : users) {
2686                    ServiceMap smap = mServiceMap.get(user);
2687                    if (smap == null) {
2688                        continue;
2689                    }
2690                    ArrayMap<ComponentName, ServiceRecord> alls = smap.mServicesByName;
2691                    for (int i=0; i<alls.size(); i++) {
2692                        ServiceRecord r1 = alls.valueAt(i);
2693                        if (componentName != null) {
2694                            if (r1.name.equals(componentName)) {
2695                                services.add(r1);
2696                            }
2697                        } else if (name != null) {
2698                            if (r1.name.flattenToString().contains(name)) {
2699                                services.add(r1);
2700                            }
2701                        } else if (System.identityHashCode(r1) == objectId) {
2702                            services.add(r1);
2703                        }
2704                    }
2705                }
2706            }
2707        }
2708
2709        if (services.size() <= 0) {
2710            return false;
2711        }
2712
2713        boolean needSep = false;
2714        for (int i=0; i<services.size(); i++) {
2715            if (needSep) {
2716                pw.println();
2717            }
2718            needSep = true;
2719            dumpService("", fd, pw, services.get(i), args, dumpAll);
2720        }
2721        return true;
2722    }
2723
2724    /**
2725     * Invokes IApplicationThread.dumpService() on the thread of the specified service if
2726     * there is a thread associated with the service.
2727     */
2728    private void dumpService(String prefix, FileDescriptor fd, PrintWriter pw,
2729            final ServiceRecord r, String[] args, boolean dumpAll) {
2730        String innerPrefix = prefix + "  ";
2731        synchronized (mAm) {
2732            pw.print(prefix); pw.print("SERVICE ");
2733                    pw.print(r.shortName); pw.print(" ");
2734                    pw.print(Integer.toHexString(System.identityHashCode(r)));
2735                    pw.print(" pid=");
2736                    if (r.app != null) pw.println(r.app.pid);
2737                    else pw.println("(not running)");
2738            if (dumpAll) {
2739                r.dump(pw, innerPrefix);
2740            }
2741        }
2742        if (r.app != null && r.app.thread != null) {
2743            pw.print(prefix); pw.println("  Client:");
2744            pw.flush();
2745            try {
2746                TransferPipe tp = new TransferPipe();
2747                try {
2748                    r.app.thread.dumpService(tp.getWriteFd().getFileDescriptor(), r, args);
2749                    tp.setBufferPrefix(prefix + "    ");
2750                    tp.go(fd);
2751                } finally {
2752                    tp.kill();
2753                }
2754            } catch (IOException e) {
2755                pw.println(prefix + "    Failure while dumping the service: " + e);
2756            } catch (RemoteException e) {
2757                pw.println(prefix + "    Got a RemoteException while dumping the service");
2758            }
2759        }
2760    }
2761
2762}
2763