content: /*
   * Copyright (C) 2012 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.android.server.am;
  
  import static android.content.pm.PackageManager.PERMISSION_GRANTED;
  import static android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_MANIFEST;
  
  import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_BACKGROUND_CHECK;
  import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_FOREGROUND_SERVICE;
  import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_MU;
  import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_PERMISSIONS_REVIEW;
  import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_SERVICE;
  import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_SERVICE_EXECUTING;
  import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_MU;
  import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_SERVICE;
  import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_SERVICE_EXECUTING;
  import static com.android.server.am.ActivityManagerDebugConfig.TAG_AM;
  import static com.android.server.am.ActivityManagerDebugConfig.TAG_WITH_CLASS_NAME;
  
  import android.app.ActivityManager;
  import android.app.ActivityManagerInternal;
  import android.app.ActivityThread;
  import android.app.AppGlobals;
  import android.app.AppOpsManager;
  import android.app.IApplicationThread;
  import android.app.IServiceConnection;
  import android.app.Notification;
  import android.app.NotificationManager;
  import android.app.PendingIntent;
  import android.app.Service;
  import android.app.ServiceStartArgs;
  import android.content.ComponentName;
  import android.content.ComponentName.WithComponentName;
  import android.content.Context;
  import android.content.IIntentSender;
  import android.content.Intent;
  import android.content.IntentSender;
  import android.content.pm.ApplicationInfo;
  import android.content.pm.PackageManager;
  import android.content.pm.ParceledListSlice;
  import android.content.pm.ResolveInfo;
  import android.content.pm.ServiceInfo;
  import android.net.Uri;
  import android.os.Binder;
  import android.os.Build;
  import android.os.Bundle;
  import android.os.DeadObjectException;
  import android.os.Handler;
  import android.os.IBinder;
  import android.os.Looper;
  import android.os.Message;
  import android.os.Process;
  import android.os.RemoteCallback;
  import android.os.RemoteException;
  import android.os.SystemClock;
  import android.os.SystemProperties;
  import android.os.TransactionTooLargeException;
  import android.os.UserHandle;
  import android.provider.Settings;
  import android.util.ArrayMap;
  import android.util.ArraySet;
  import android.util.EventLog;
  import android.util.PrintWriterPrinter;
  import android.util.Slog;
  import android.util.SparseArray;
  import android.util.StatsLog;
  import android.util.TimeUtils;
  import android.util.proto.ProtoOutputStream;
  import android.webkit.WebViewZygote;
  
  import com.android.internal.R;
  import com.android.internal.app.procstats.ServiceState;
  import com.android.internal.messages.nano.SystemMessageProto;
  import com.android.internal.notification.SystemNotificationChannels;
  import com.android.internal.os.BatteryStatsImpl;
  import com.android.internal.os.TransferPipe;
  import com.android.internal.util.DumpUtils;
  import com.android.internal.util.FastPrintWriter;
  import com.android.server.AppStateTracker;
  import com.android.server.LocalServices;
  import com.android.server.SystemService;
  import com.android.server.am.ActivityManagerService.ItemMatcher;
  import com.android.server.uri.NeededUriGrants;
  import com.android.server.wm.ActivityServiceConnectionsHolder;
  
  import java.io.FileDescriptor;
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.io.StringWriter;
  import java.util.ArrayList;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Set;
  import java.util.function.Predicate;
  
  public final class ActiveServices {
      private static final String TAG = TAG_WITH_CLASS_NAME ? "ActiveServices" : TAG_AM;
      private static final String TAG_MU = TAG + POSTFIX_MU;
      private static final String TAG_SERVICE = TAG + POSTFIX_SERVICE;
      private static final String TAG_SERVICE_EXECUTING = TAG + POSTFIX_SERVICE_EXECUTING;
  
      private static final boolean DEBUG_DELAYED_SERVICE = DEBUG_SERVICE;
      private static final boolean DEBUG_DELAYED_STARTS = DEBUG_DELAYED_SERVICE;
  
      private static final boolean LOG_SERVICE_START_STOP = false;
  
      private static final boolean SHOW_DUNGEON_NOTIFICATION = false;
  
      // How long we wait for a service to finish executing.
      static final int SERVICE_TIMEOUT = 20*1000;
  
      // How long we wait for a service to finish executing.
      static final int SERVICE_BACKGROUND_TIMEOUT = SERVICE_TIMEOUT * 10;
  
      // How long the startForegroundService() grace period is to get around to
      // calling startForeground() before we ANR + stop it.
      static final int SERVICE_START_FOREGROUND_TIMEOUT = 10*1000;
  
      final ActivityManagerService mAm;
  
      // Maximum number of services that we allow to start in the background
      // at the same time.
      final int mMaxStartingBackground;
  
      final SparseArray<ServiceMap> mServiceMap = new SparseArray<>();
  
      /**
       * All currently bound service connections.  Keys are the IBinder of
       * the client's IServiceConnection.
       */
      final ArrayMap<IBinder, ArrayList<ConnectionRecord>> mServiceConnections = new ArrayMap<>();
  
      /**
       * List of services that we have been asked to start,
       * but haven't yet been able to.  It is used to hold start requests
       * while waiting for their corresponding application thread to get
       * going.
       */
      final ArrayList<ServiceRecord> mPendingServices = new ArrayList<>();
  
      /**
       * List of services that are scheduled to restart following a crash.
       */
      final ArrayList<ServiceRecord> mRestartingServices = new ArrayList<>();
  
      /**
       * List of services that are in the process of being destroyed.
       */
      final ArrayList<ServiceRecord> mDestroyingServices = new ArrayList<>();
  
      /** Temporary list for holding the results of calls to {@link #collectPackageServicesLocked} */
      private ArrayList<ServiceRecord> mTmpCollectionResults = null;
  
      /**
       * For keeping ActiveForegroundApps retaining state while the screen is off.
       */
      boolean mScreenOn = true;
  
      /** Amount of time to allow a last ANR message to exist before freeing the memory. */
      static final int LAST_ANR_LIFETIME_DURATION_MSECS = 2 * 60 * 60 * 1000; // Two hours
  
      String mLastAnrDump;
  
      final Runnable mLastAnrDumpClearer = new Runnable() {
          @Override public void run() {
              synchronized (mAm) {
                  mLastAnrDump = null;
              }
          }
      };
  
      /**
       * Watch for apps being put into forced app standby, so we can step their fg
       * services down.
       */
      class ForcedStandbyListener extends AppStateTracker.Listener {
          @Override
          public void stopForegroundServicesForUidPackage(final int uid, final String packageName) {
              synchronized (mAm) {
                  final ServiceMap smap = getServiceMapLocked(UserHandle.getUserId(uid));
                  final int N = smap.mServicesByInstanceName.size();
                  final ArrayList<ServiceRecord> toStop = new ArrayList<>(N);
                  for (int i = 0; i < N; i++) {
                      final ServiceRecord r = smap.mServicesByInstanceName.valueAt(i);
                      if (uid == r.serviceInfo.applicationInfo.uid
                              || packageName.equals(r.serviceInfo.packageName)) {
                          if (r.isForeground) {
                              toStop.add(r);
                          }
                      }
                  }
  
                  // Now stop them all
                  final int numToStop = toStop.size();
                  if (numToStop > 0 && DEBUG_FOREGROUND_SERVICE) {
                      Slog.i(TAG, "Package " + packageName + "/" + uid
                              + " entering FAS with foreground services");
                  }
                  for (int i = 0; i < numToStop; i++) {
                      final ServiceRecord r = toStop.get(i);
                      if (DEBUG_FOREGROUND_SERVICE) {
                          Slog.i(TAG, "  Stopping fg for service " + r);
                      }
                      setServiceForegroundInnerLocked(r, 0, null, 0, 0);
                  }
              }
          }
      }
  
      /**
       * Information about an app that is currently running one or more foreground services.
       * (This maps directly to the running apps we show in the notification.)
       */
      static final class ActiveForegroundApp {
          String mPackageName;
          int mUid;
          CharSequence mLabel;
          boolean mShownWhileScreenOn;
          boolean mAppOnTop;
          boolean mShownWhileTop;
          long mStartTime;
          long mStartVisibleTime;
          long mEndTime;
          int mNumActive;
  
          // Temp output of foregroundAppShownEnoughLocked
          long mHideTime;
      }
  
      /**
       * Information about services for a single user.
       */
      final class ServiceMap extends Handler {
          final int mUserId;
          final ArrayMap<ComponentName, ServiceRecord> mServicesByInstanceName = new ArrayMap<>();
          final ArrayMap<Intent.FilterComparison, ServiceRecord> mServicesByIntent = new ArrayMap<>();
  
          final ArrayList<ServiceRecord> mDelayedStartList = new ArrayList<>();
          /* XXX eventually I'd like to have this based on processes instead of services.
           * That is, if we try to start two services in a row both running in the same
           * process, this should be one entry in mStartingBackground for that one process
           * that remains until all services in it are done.
          final ArrayMap<ProcessRecord, DelayingProcess> mStartingBackgroundMap
                  = new ArrayMap<ProcessRecord, DelayingProcess>();
          final ArrayList<DelayingProcess> mStartingProcessList
                  = new ArrayList<DelayingProcess>();
          */
  
          final ArrayList<ServiceRecord> mStartingBackground = new ArrayList<>();
  
          final ArrayMap<String, ActiveForegroundApp> mActiveForegroundApps = new ArrayMap<>();
          boolean mActiveForegroundAppsChanged;
  
          static final int MSG_BG_START_TIMEOUT = 1;
          static final int MSG_UPDATE_FOREGROUND_APPS = 2;
  
          ServiceMap(Looper looper, int userId) {
              super(looper);
              mUserId = userId;
          }
  
          @Override
          public void handleMessage(Message msg) {
              switch (msg.what) {
                  case MSG_BG_START_TIMEOUT: {
                      synchronized (mAm) {
                          rescheduleDelayedStartsLocked();
                      }
                  } break;
                  case MSG_UPDATE_FOREGROUND_APPS: {
                      updateForegroundApps(this);
                  } break;
              }
          }
  
          void ensureNotStartingBackgroundLocked(ServiceRecord r) {
              if (mStartingBackground.remove(r)) {
                  if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE,
                          "No longer background starting: " + r);
                  rescheduleDelayedStartsLocked();
              }
              if (mDelayedStartList.remove(r)) {
                  if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE, "No longer delaying start: " + r);
              }
          }
  
          void rescheduleDelayedStartsLocked() {
              removeMessages(MSG_BG_START_TIMEOUT);
              final long now = SystemClock.uptimeMillis();
              for (int i=0, N=mStartingBackground.size(); i<N; i++) {
                  ServiceRecord r = mStartingBackground.get(i);
                  if (r.startingBgTimeout <= now) {
                      Slog.i(TAG, "Waited long enough for: " + r);
                      mStartingBackground.remove(i);
                      N--;
                      i--;
                  }
              }
              while (mDelayedStartList.size() > 0
                      && mStartingBackground.size() < mMaxStartingBackground) {
                  ServiceRecord r = mDelayedStartList.remove(0);
                  if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE,
                          "REM FR DELAY LIST (exec next): " + r);
                  if (DEBUG_DELAYED_SERVICE) {
                      if (mDelayedStartList.size() > 0) {
                          Slog.v(TAG_SERVICE, "Remaining delayed list:");
                          for (int i=0; i<mDelayedStartList.size(); i++) {
                              Slog.v(TAG_SERVICE, "  #" + i + ": " + mDelayedStartList.get(i));
                          }
                      }
                  }
                  r.delayed = false;
                  if (r.pendingStarts.size() <= 0) {
                      Slog.wtf(TAG, "**** NO PENDING STARTS! " + r + " startReq=" + r.startRequested
                              + " delayedStop=" + r.delayedStop);
                  } else {
                      try {
                          startServiceInnerLocked(this, r.pendingStarts.get(0).intent, r, false,
                                  true);
                      } catch (TransactionTooLargeException e) {
                          // Ignore, nobody upstack cares.
                      }
                  }
              }
              if (mStartingBackground.size() > 0) {
                  ServiceRecord next = mStartingBackground.get(0);
                  long when = next.startingBgTimeout > now ? next.startingBgTimeout : now;
                  if (DEBUG_DELAYED_SERVICE) Slog.v(TAG_SERVICE, "Top bg start is " + next
                          + ", can delay others up to " + when);
                  Message msg = obtainMessage(MSG_BG_START_TIMEOUT);
                  sendMessageAtTime(msg, when);
              }
              if (mStartingBackground.size() < mMaxStartingBackground) {
                  mAm.backgroundServicesFinishedLocked(mUserId);
              }
          }
      }
  
      public ActiveServices(ActivityManagerService service) {
          mAm = service;
          int maxBg = 0;
          try {
              maxBg = Integer.parseInt(SystemProperties.get("ro.config.max_starting_bg", "0"));
          } catch(RuntimeException e) {
          }
          mMaxStartingBackground = maxBg > 0
                  ? maxBg : ActivityManager.isLowRamDeviceStatic() ? 1 : 8;
      }
  
      void systemServicesReady() {
          AppStateTracker ast = LocalServices.getService(AppStateTracker.class);
          ast.addListener(new ForcedStandbyListener());
      }
  
      ServiceRecord getServiceByNameLocked(ComponentName name, int callingUser) {
          // TODO: Deal with global services
          if (DEBUG_MU)
              Slog.v(TAG_MU, "getServiceByNameLocked(" + name + "), callingUser = " + callingUser);
          return getServiceMapLocked(callingUser).mServicesByInstanceName.get(name);
      }
  
      boolean hasBackgroundServicesLocked(int callingUser) {
          ServiceMap smap = mServiceMap.get(callingUser);
          return smap != null ? smap.mStartingBackground.size() >= mMaxStartingBackground : false;
      }
  
      private ServiceMap getServiceMapLocked(int callingUser) {
          ServiceMap smap = mServiceMap.get(callingUser);
          if (smap == null) {
              smap = new ServiceMap(mAm.mHandler.getLooper(), callingUser);
              mServiceMap.put(callingUser, smap);
          }
          return smap;
      }
  
      ArrayMap<ComponentName, ServiceRecord> getServicesLocked(int callingUser) {
          return getServiceMapLocked(callingUser).mServicesByInstanceName;
      }
  
      private boolean appRestrictedAnyInBackground(final int uid, final String packageName) {
          final int mode = mAm.mAppOpsService.checkOperation(
                  AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, uid, packageName);
          return (mode != AppOpsManager.MODE_ALLOWED);
      }
  
      ComponentName startServiceLocked(IApplicationThread caller, Intent service, String resolvedType,
              int callingPid, int callingUid, boolean fgRequired, String callingPackage, final int userId)
              throws TransactionTooLargeException {
          return startServiceLocked(caller, service, resolvedType, callingPid, callingUid, fgRequired,
                  callingPackage, userId, false);
      }
  
      ComponentName startServiceLocked(IApplicationThread caller, Intent service, String resolvedType,
              int callingPid, int callingUid, boolean fgRequired, String callingPackage,
              final int userId, boolean allowBackgroundActivityStarts)
              throws TransactionTooLargeException {
          if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE, "startService: " + service
                  + " type=" + resolvedType + " args=" + service.getExtras());
  
          final boolean callerFg;
          if (caller != null) {
              final ProcessRecord callerApp = mAm.getRecordForAppLocked(caller);
              if (callerApp == null) {
                  throw new SecurityException(
                          "Unable to find app for caller " + caller
                          + " (pid=" + callingPid
                          + ") when starting service " + service);
              }
              callerFg = callerApp.setSchedGroup != ProcessList.SCHED_GROUP_BACKGROUND;
          } else {
              callerFg = true;
          }
  
          ServiceLookupResult res =
              retrieveServiceLocked(service, null, resolvedType, callingPackage,
                      callingPid, callingUid, userId, true, callerFg, false, false);
          if (res == null) {
              return null;
          }
          if (res.record == null) {
              return new ComponentName("!", res.permission != null
                      ? res.permission : "private to package");
          }
  
          ServiceRecord r = res.record;
  
          if (!mAm.mUserController.exists(r.userId)) {
              Slog.w(TAG, "Trying to start service with non-existent user! " + r.userId);
              return null;
          }
  
          // If we're starting indirectly (e.g. from PendingIntent), figure out whether
          // we're launching into an app in a background state.  This keys off of the same
          // idleness state tracking as e.g. O+ background service start policy.
          final boolean bgLaunch = !mAm.isUidActiveLocked(r.appInfo.uid);
  
          // If the app has strict background restrictions, we treat any bg service
          // start analogously to the legacy-app forced-restrictions case, regardless
          // of its target SDK version.
          boolean forcedStandby = false;
          if (bgLaunch && appRestrictedAnyInBackground(r.appInfo.uid, r.packageName)) {
              if (DEBUG_FOREGROUND_SERVICE) {
                  Slog.d(TAG, "Forcing bg-only service start only for " + r.shortInstanceName
                          + " : bgLaunch=" + bgLaunch + " callerFg=" + callerFg);
              }
              forcedStandby = true;
          }
  
          // If this is a direct-to-foreground start, make sure it is allowed as per the app op.
          boolean forceSilentAbort = false;
          if (fgRequired) {
              final int mode = mAm.mAppOpsService.checkOperation(
                      AppOpsManager.OP_START_FOREGROUND, r.appInfo.uid, r.packageName);
              switch (mode) {
                  case AppOpsManager.MODE_ALLOWED:
                  case AppOpsManager.MODE_DEFAULT:
                      // All okay.
                      break;
                  case AppOpsManager.MODE_IGNORED:
                      // Not allowed, fall back to normal start service, failing siliently
                      // if background check restricts that.
                      Slog.w(TAG, "startForegroundService not allowed due to app op: service "
                              + service + " to " + r.shortInstanceName
                              + " from pid=" + callingPid + " uid=" + callingUid
                              + " pkg=" + callingPackage);
                      fgRequired = false;
                      forceSilentAbort = true;
                      break;
                  default:
                      return new ComponentName("!!", "foreground not allowed as per app op");
              }
          }
  
          // If this isn't a direct-to-foreground start, check our ability to kick off an
          // arbitrary service
          if (forcedStandby || (!r.startRequested && !fgRequired)) {
              // Before going further -- if this app is not allowed to start services in the
              // background, then at this point we aren't going to let it period.
              final int allowed = mAm.getAppStartModeLocked(r.appInfo.uid, r.packageName,
                      r.appInfo.targetSdkVersion, callingPid, false, false, forcedStandby);
              if (allowed != ActivityManager.APP_START_MODE_NORMAL) {
                  Slog.w(TAG, "Background start not allowed: service "
                          + service + " to " + r.shortInstanceName
                          + " from pid=" + callingPid + " uid=" + callingUid
                          + " pkg=" + callingPackage + " startFg?=" + fgRequired);
                  if (allowed == ActivityManager.APP_START_MODE_DELAYED || forceSilentAbort) {
                      // In this case we are silently disabling the app, to disrupt as
                      // little as possible existing apps.
                      return null;
                  }
                  if (forcedStandby) {
                      // This is an O+ app, but we might be here because the user has placed
                      // it under strict background restrictions.  Don't punish the app if it's
                      // trying to do the right thing but we're denying it for that reason.
                      if (fgRequired) {
                          if (DEBUG_BACKGROUND_CHECK) {
                              Slog.v(TAG, "Silently dropping foreground service launch due to FAS");
                          }
                          return null;
                      }
                  }
                  // This app knows it is in the new model where this operation is not
                  // allowed, so tell it what has happened.
                  UidRecord uidRec = mAm.mProcessList.getUidRecordLocked(r.appInfo.uid);
                  return new ComponentName("?", "app is in background uid " + uidRec);
              }
          }
  
          // At this point we've applied allowed-to-start policy based on whether this was
          // an ordinary startService() or a startForegroundService().  Now, only require that
          // the app follow through on the startForegroundService() -> startForeground()
          // contract if it actually targets O+.
          if (r.appInfo.targetSdkVersion < Build.VERSION_CODES.O && fgRequired) {
              if (DEBUG_BACKGROUND_CHECK || DEBUG_FOREGROUND_SERVICE) {
                  Slog.i(TAG, "startForegroundService() but host targets "
                          + r.appInfo.targetSdkVersion + " - not requiring startForeground()");
              }
              fgRequired = false;
          }
  
          NeededUriGrants neededGrants = mAm.mUgmInternal.checkGrantUriPermissionFromIntent(
                  callingUid, r.packageName, service, service.getFlags(), null, r.userId);
  
          // If permissions need a review before any of the app components can run,
          // we do not start the service and launch a review activity if the calling app
          // is in the foreground passing it a pending intent to start the service when
          // review is completed.
  
          // XXX This is not dealing with fgRequired!
          if (!requestStartTargetPermissionsReviewIfNeededLocked(r, callingPackage,
                  callingUid, service, callerFg, userId)) {
              return null;
          }
  
          if (unscheduleServiceRestartLocked(r, callingUid, false)) {
              if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "START SERVICE WHILE RESTART PENDING: " + r);
          }
          r.lastActivity = SystemClock.uptimeMillis();
          r.startRequested = true;
          r.delayedStop = false;
          r.fgRequired = fgRequired;
          r.pendingStarts.add(new ServiceRecord.StartItem(r, false, r.makeNextStartId(),
                  service, neededGrants, callingUid));
  
          if (fgRequired) {
              // We are now effectively running a foreground service.
              ServiceState stracker = r.getTracker();
              if (stracker != null) {
                  stracker.setForeground(true, mAm.mProcessStats.getMemFactorLocked(),
                          r.lastActivity);
              }
              mAm.mAppOpsService.startOperation(AppOpsManager.getToken(mAm.mAppOpsService),
                      AppOpsManager.OP_START_FOREGROUND, r.appInfo.uid, r.packageName, true);
          }
  
          final ServiceMap smap = getServiceMapLocked(r.userId);
          boolean addToStarting = false;
          if (!callerFg && !fgRequired && r.app == null
                  && mAm.mUserController.hasStartedUserState(r.userId)) {
              ProcessRecord proc = mAm.getProcessRecordLocked(r.processName, r.appInfo.uid, false);
              if (proc == null || proc.getCurProcState() > ActivityManager.PROCESS_STATE_RECEIVER) {
                  // If this is not coming from a foreground caller, then we may want
                  // to delay the start if there are already other background services
                  // that are starting.  This is to avoid process start spam when lots
                  // of applications are all handling things like connectivity broadcasts.
                  // We only do this for cached processes, because otherwise an application
                  // can have assumptions about calling startService() for a service to run
                  // in its own process, and for that process to not be killed before the
                  // service is started.  This is especially the case for receivers, which
                  // may start a service in onReceive() to do some additional work and have
                  // initialized some global state as part of that.
                  if (DEBUG_DELAYED_SERVICE) Slog.v(TAG_SERVICE, "Potential start delay of "
                          + r + " in " + proc);
                  if (r.delayed) {
                      // This service is already scheduled for a delayed start; just leave
                      // it still waiting.
                      if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE, "Continuing to delay: " + r);
                      return r.name;
                  }
                  if (smap.mStartingBackground.size() >= mMaxStartingBackground) {
                      // Something else is starting, delay!
                      Slog.i(TAG_SERVICE, "Delaying start of: " + r);
                      smap.mDelayedStartList.add(r);
                      r.delayed = true;
                      return r.name;
                  }
                  if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE, "Not delaying: " + r);
                  addToStarting = true;
              } else if (proc.getCurProcState() >= ActivityManager.PROCESS_STATE_SERVICE) {
                  // We slightly loosen when we will enqueue this new service as a background
                  // starting service we are waiting for, to also include processes that are
                  // currently running other services or receivers.
                  addToStarting = true;
                  if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE,
                          "Not delaying, but counting as bg: " + r);
              } else if (DEBUG_DELAYED_STARTS) {
                  StringBuilder sb = new StringBuilder(128);
                  sb.append("Not potential delay (state=").append(proc.getCurProcState())
                          .append(' ').append(proc.adjType);
                  String reason = proc.makeAdjReason();
                  if (reason != null) {
                      sb.append(' ');
                      sb.append(reason);
                  }
                  sb.append("): ");
                  sb.append(r.toString());
                  Slog.v(TAG_SERVICE, sb.toString());
              }
          } else if (DEBUG_DELAYED_STARTS) {
              if (callerFg || fgRequired) {
                  Slog.v(TAG_SERVICE, "Not potential delay (callerFg=" + callerFg + " uid="
                          + callingUid + " pid=" + callingPid + " fgRequired=" + fgRequired + "): " + r);
              } else if (r.app != null) {
                  Slog.v(TAG_SERVICE, "Not potential delay (cur app=" + r.app + "): " + r);
              } else {
                  Slog.v(TAG_SERVICE,
                          "Not potential delay (user " + r.userId + " not started): " + r);
              }
          }
  
          if (allowBackgroundActivityStarts) {
              r.whitelistBgActivityStartsOnServiceStart();
          }
  
          ComponentName cmp = startServiceInnerLocked(smap, service, r, callerFg, addToStarting);
          return cmp;
      }
  
      private boolean requestStartTargetPermissionsReviewIfNeededLocked(ServiceRecord r,
              String callingPackage, int callingUid, Intent service, boolean callerFg,
              final int userId) {
          if (mAm.getPackageManagerInternalLocked().isPermissionsReviewRequired(
                  r.packageName, r.userId)) {
  
              // Show a permission review UI only for starting from a foreground app
              if (!callerFg) {
                  Slog.w(TAG, "u" + r.userId + " Starting a service in package"
                          + r.packageName + " requires a permissions review");
                  return false;
              }
  
              IIntentSender target = mAm.mPendingIntentController.getIntentSender(
                      ActivityManager.INTENT_SENDER_SERVICE, callingPackage,
                      callingUid, userId, null, null, 0, new Intent[]{service},
                      new String[]{service.resolveType(mAm.mContext.getContentResolver())},
                      PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_ONE_SHOT
                              | PendingIntent.FLAG_IMMUTABLE, null);
  
              final Intent intent = new Intent(Intent.ACTION_REVIEW_PERMISSIONS);
              intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                      | Intent.FLAG_ACTIVITY_MULTIPLE_TASK
                      | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
              intent.putExtra(Intent.EXTRA_PACKAGE_NAME, r.packageName);
              intent.putExtra(Intent.EXTRA_INTENT, new IntentSender(target));
  
              if (DEBUG_PERMISSIONS_REVIEW) {
                  Slog.i(TAG, "u" + r.userId + " Launching permission review for package "
                          + r.packageName);
              }
  
              mAm.mHandler.post(new Runnable() {
                  @Override
                  public void run() {
                      mAm.mContext.startActivityAsUser(intent, new UserHandle(userId));
                  }
              });
  
              return false;
          }
  
          return  true;
      }
  
      ComponentName startServiceInnerLocked(ServiceMap smap, Intent service, ServiceRecord r,
              boolean callerFg, boolean addToStarting) throws TransactionTooLargeException {
          ServiceState stracker = r.getTracker();
          if (stracker != null) {
              stracker.setStarted(true, mAm.mProcessStats.getMemFactorLocked(), r.lastActivity);
          }
          r.callStart = false;
          StatsLog.write(StatsLog.SERVICE_STATE_CHANGED, r.appInfo.uid, r.name.getPackageName(),
                  r.name.getClassName(), StatsLog.SERVICE_STATE_CHANGED__STATE__START);
          synchronized (r.stats.getBatteryStats()) {
              r.stats.startRunningLocked();
          }
          String error = bringUpServiceLocked(r, service.getFlags(), callerFg, false, false);
          if (error != null) {
              return new ComponentName("!!", error);
          }
  
          if (r.startRequested && addToStarting) {
              boolean first = smap.mStartingBackground.size() == 0;
              smap.mStartingBackground.add(r);
              r.startingBgTimeout = SystemClock.uptimeMillis() + mAm.mConstants.BG_START_TIMEOUT;
              if (DEBUG_DELAYED_SERVICE) {
                  RuntimeException here = new RuntimeException("here");
                  here.fillInStackTrace();
                  Slog.v(TAG_SERVICE, "Starting background (first=" + first + "): " + r, here);
              } else if (DEBUG_DELAYED_STARTS) {
                  Slog.v(TAG_SERVICE, "Starting background (first=" + first + "): " + r);
              }
              if (first) {
                  smap.rescheduleDelayedStartsLocked();
              }
          } else if (callerFg || r.fgRequired) {
              smap.ensureNotStartingBackgroundLocked(r);
          }
  
          return r.name;
      }
  
      private void stopServiceLocked(ServiceRecord service) {
          if (service.delayed) {
              // If service isn't actually running, but is being held in the
              // delayed list, then we need to keep it started but note that it
              // should be stopped once no longer delayed.
              if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE, "Delaying stop of pending: " + service);
              service.delayedStop = true;
              return;
          }
          StatsLog.write(StatsLog.SERVICE_STATE_CHANGED, service.appInfo.uid,
                  service.name.getPackageName(), service.name.getClassName(),
                  StatsLog.SERVICE_STATE_CHANGED__STATE__STOP);
          synchronized (service.stats.getBatteryStats()) {
              service.stats.stopRunningLocked();
          }
          service.startRequested = false;
          if (service.tracker != null) {
              service.tracker.setStarted(false, mAm.mProcessStats.getMemFactorLocked(),
                      SystemClock.uptimeMillis());
          }
          service.callStart = false;
  
          bringDownServiceIfNeededLocked(service, false, false);
      }
  
      int stopServiceLocked(IApplicationThread caller, Intent service,
              String resolvedType, int userId) {
          if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "stopService: " + service
                  + " type=" + resolvedType);
  
          final ProcessRecord callerApp = mAm.getRecordForAppLocked(caller);
          if (caller != null && callerApp == null) {
              throw new SecurityException(
                      "Unable to find app for caller " + caller
                      + " (pid=" + Binder.getCallingPid()
                      + ") when stopping service " + service);
          }
  
          // If this service is active, make sure it is stopped.
          ServiceLookupResult r = retrieveServiceLocked(service, null, resolvedType, null,
                  Binder.getCallingPid(), Binder.getCallingUid(), userId, false, false, false, false);
          if (r != null) {
              if (r.record != null) {
                  final long origId = Binder.clearCallingIdentity();
                  try {
                      stopServiceLocked(r.record);
                  } finally {
                      Binder.restoreCallingIdentity(origId);
                  }
                  return 1;
              }
              return -1;
          }
  
          return 0;
      }
  
      void stopInBackgroundLocked(int uid) {
          // Stop all services associated with this uid due to it going to the background
          // stopped state.
          ServiceMap services = mServiceMap.get(UserHandle.getUserId(uid));
          ArrayList<ServiceRecord> stopping = null;
          if (services != null) {
              for (int i = services.mServicesByInstanceName.size() - 1; i >= 0; i--) {
                  ServiceRecord service = services.mServicesByInstanceName.valueAt(i);
                  if (service.appInfo.uid == uid && service.startRequested) {
                      if (mAm.getAppStartModeLocked(service.appInfo.uid, service.packageName,
                              service.appInfo.targetSdkVersion, -1, false, false, false)
                              != ActivityManager.APP_START_MODE_NORMAL) {
                          if (stopping == null) {
                              stopping = new ArrayList<>();
                          }
                          String compName = service.shortInstanceName;
                          EventLogTags.writeAmStopIdleService(service.appInfo.uid, compName);
                          StringBuilder sb = new StringBuilder(64);
                          sb.append("Stopping service due to app idle: ");
                          UserHandle.formatUid(sb, service.appInfo.uid);
                          sb.append(" ");
                          TimeUtils.formatDuration(service.createRealTime
                                  - SystemClock.elapsedRealtime(), sb);
                          sb.append(" ");
                          sb.append(compName);
                          Slog.w(TAG, sb.toString());
                          stopping.add(service);
  
                          // If the app is under bg restrictions, also make sure that
                          // any notification is dismissed
                          if (appRestrictedAnyInBackground(
                                  service.appInfo.uid, service.packageName)) {
                              cancelForegroundNotificationLocked(service);
                          }
                      }
                  }
              }
              if (stopping != null) {
                  for (int i=stopping.size()-1; i>=0; i--) {
                      ServiceRecord service = stopping.get(i);
                      service.delayed = false;
                      services.ensureNotStartingBackgroundLocked(service);
                      stopServiceLocked(service);
                  }
              }
          }
      }
  
      void killMisbehavingService(ServiceRecord r,
              int appUid, int appPid, String localPackageName) {
          synchronized (mAm) {
              stopServiceLocked(r);
              mAm.crashApplication(appUid, appPid, localPackageName, -1,
                      "Bad notification for startForeground", true /*force*/);
          }
      }
  
      IBinder peekServiceLocked(Intent service, String resolvedType, String callingPackage) {
          ServiceLookupResult r = retrieveServiceLocked(service, null, resolvedType, callingPackage,
                  Binder.getCallingPid(), Binder.getCallingUid(),
                  UserHandle.getCallingUserId(), false, false, false, false);
  
          IBinder ret = null;
          if (r != null) {
              // r.record is null if findServiceLocked() failed the caller permission check
              if (r.record == null) {
                  throw new SecurityException(
                          "Permission Denial: Accessing service"
                          + " from pid=" + Binder.getCallingPid()
                          + ", uid=" + Binder.getCallingUid()
                          + " requires " + r.permission);
              }
              IntentBindRecord ib = r.record.bindings.get(r.record.intent);
              if (ib != null) {
                  ret = ib.binder;
              }
          }
  
          return ret;
      }
  
      boolean stopServiceTokenLocked(ComponentName className, IBinder token,
              int startId) {
          if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "stopServiceToken: " + className
                  + " " + token + " startId=" + startId);
          ServiceRecord r = findServiceLocked(className, token, UserHandle.getCallingUserId());
          if (r != null) {
              if (startId >= 0) {
                  // Asked to only stop if done with all work.  Note that
                  // to avoid leaks, we will take this as dropping all
                  // start items up to and including this one.
                  ServiceRecord.StartItem si = r.findDeliveredStart(startId, false, false);
                  if (si != null) {
                      while (r.deliveredStarts.size() > 0) {
                          ServiceRecord.StartItem cur = r.deliveredStarts.remove(0);
                          cur.removeUriPermissionsLocked();
                          if (cur == si) {
                              break;
                          }
                      }
                  }
  
                  if (r.getLastStartId() != startId) {
                      return false;
                  }
  
                  if (r.deliveredStarts.size() > 0) {
                      Slog.w(TAG, "stopServiceToken startId " + startId
                              + " is last, but have " + r.deliveredStarts.size()
                              + " remaining args");
                  }
              }
  
              StatsLog.write(StatsLog.SERVICE_STATE_CHANGED, r.appInfo.uid, r.name.getPackageName(),
                      r.name.getClassName(), StatsLog.SERVICE_STATE_CHANGED__STATE__STOP);
              synchronized (r.stats.getBatteryStats()) {
                  r.stats.stopRunningLocked();
              }
              r.startRequested = false;
              if (r.tracker != null) {
                  r.tracker.setStarted(false, mAm.mProcessStats.getMemFactorLocked(),
                          SystemClock.uptimeMillis());
              }
              r.callStart = false;
              final long origId = Binder.clearCallingIdentity();
              bringDownServiceIfNeededLocked(r, false, false);
              Binder.restoreCallingIdentity(origId);
              return true;
          }
          return false;
      }
  
      public void setServiceForegroundLocked(ComponentName className, IBinder token,
              int id, Notification notification, int flags, int foregroundServiceType) {
          final int userId = UserHandle.getCallingUserId();
          final long origId = Binder.clearCallingIdentity();
          try {
              ServiceRecord r = findServiceLocked(className, token, userId);
              if (r != null) {
                  setServiceForegroundInnerLocked(r, id, notification, flags, foregroundServiceType);
              }
          } finally {
              Binder.restoreCallingIdentity(origId);
          }
      }
  
      /**
       * Return the current foregroundServiceType of the ServiceRecord.
       * @param className ComponentName of the Service class.
       * @param token IBinder token.
       * @return current foreground service type.
       */
      public int getForegroundServiceTypeLocked(ComponentName className, IBinder token) {
          final int userId = UserHandle.getCallingUserId();
          final long origId = Binder.clearCallingIdentity();
          int ret = ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE;
          try {
              ServiceRecord r = findServiceLocked(className, token, userId);
              if (r != null) {
                  ret = r.foregroundServiceType;
              }
          } finally {
              Binder.restoreCallingIdentity(origId);
          }
          return ret;
      }
  
      boolean foregroundAppShownEnoughLocked(ActiveForegroundApp aa, long nowElapsed) {
          if (DEBUG_FOREGROUND_SERVICE) Slog.d(TAG, "Shown enough: pkg=" + aa.mPackageName + ", uid="
                  + aa.mUid);
          boolean canRemove = false;
          aa.mHideTime = Long.MAX_VALUE;
          if (aa.mShownWhileTop) {
              // If the app was ever at the top of the screen while the foreground
              // service was running, then we can always just immediately remove it.
              canRemove = true;
              if (DEBUG_FOREGROUND_SERVICE) Slog.d(TAG, "YES - shown while on top");
          } else if (mScreenOn || aa.mShownWhileScreenOn) {
              final long minTime = aa.mStartVisibleTime
                      + (aa.mStartTime != aa.mStartVisibleTime
                              ? mAm.mConstants.FGSERVICE_SCREEN_ON_AFTER_TIME
                              : mAm.mConstants.FGSERVICE_MIN_SHOWN_TIME);
              if (nowElapsed >= minTime) {
                  // If shown while the screen is on, and it has been shown for
                  // at least the minimum show time, then we can now remove it.
                  if (DEBUG_FOREGROUND_SERVICE) Slog.d(TAG, "YES - shown long enough with screen on");
                  canRemove = true;
              } else {
                  // This is when we will be okay to stop telling the user.
                  long reportTime = nowElapsed + mAm.mConstants.FGSERVICE_MIN_REPORT_TIME;
                  aa.mHideTime = reportTime > minTime ? reportTime : minTime;
                  if (DEBUG_FOREGROUND_SERVICE) Slog.d(TAG, "NO -- wait " + (aa.mHideTime-nowElapsed)
                          + " with screen on");
              }
          } else {
              final long minTime = aa.mEndTime
                      + mAm.mConstants.FGSERVICE_SCREEN_ON_BEFORE_TIME;
              if (nowElapsed >= minTime) {
                  // If the foreground service has only run while the screen is
                  // off, but it has been gone now for long enough that we won't
                  // care to tell the user about it when the screen comes back on,
                  // then we can remove it now.
                  if (DEBUG_FOREGROUND_SERVICE) Slog.d(TAG, "YES - gone long enough with screen off");
                  canRemove = true;
              } else {
                  // This is when we won't care about this old fg service.
                  aa.mHideTime = minTime;
                  if (DEBUG_FOREGROUND_SERVICE) Slog.d(TAG, "NO -- wait " + (aa.mHideTime-nowElapsed)
                          + " with screen off");
              }
          }
          return canRemove;
      }
  
      void updateForegroundApps(ServiceMap smap) {
          // This is called from the handler without the lock held.
          ArrayList<ActiveForegroundApp> active = null;
          synchronized (mAm) {
              final long now = SystemClock.elapsedRealtime();
              long nextUpdateTime = Long.MAX_VALUE;
              if (smap != null) {
                  if (DEBUG_FOREGROUND_SERVICE) Slog.d(TAG, "Updating foreground apps for user "
                          + smap.mUserId);
                  for (int i = smap.mActiveForegroundApps.size()-1; i >= 0; i--) {
                      ActiveForegroundApp aa = smap.mActiveForegroundApps.valueAt(i);
                      if (aa.mEndTime != 0) {
                          boolean canRemove = foregroundAppShownEnoughLocked(aa, now);
                          if (canRemove) {
                              // This was up for longer than the timeout, so just remove immediately.
                              smap.mActiveForegroundApps.removeAt(i);
                              smap.mActiveForegroundAppsChanged = true;
                              continue;
                          }
                          if (aa.mHideTime < nextUpdateTime) {
                              nextUpdateTime = aa.mHideTime;
                          }
                      }
                      if (!aa.mAppOnTop) {
                          if (active == null) {
                              active = new ArrayList<>();
                          }
                          if (DEBUG_FOREGROUND_SERVICE) Slog.d(TAG, "Adding active: pkg="
                                  + aa.mPackageName + ", uid=" + aa.mUid);
                          active.add(aa);
                      }
                  }
                  smap.removeMessages(ServiceMap.MSG_UPDATE_FOREGROUND_APPS);
                  if (nextUpdateTime < Long.MAX_VALUE) {
                      if (DEBUG_FOREGROUND_SERVICE) Slog.d(TAG, "Next update time in: "
                              + (nextUpdateTime-now));
                      Message msg = smap.obtainMessage(ServiceMap.MSG_UPDATE_FOREGROUND_APPS);
                      smap.sendMessageAtTime(msg, nextUpdateTime
                              + SystemClock.uptimeMillis() - SystemClock.elapsedRealtime());
                  }
              }
              if (!smap.mActiveForegroundAppsChanged) {
                  return;
              }
              smap.mActiveForegroundAppsChanged = false;
          }
  
          if (!SHOW_DUNGEON_NOTIFICATION) {
              return;
          }
  
          final NotificationManager nm = (NotificationManager) mAm.mContext.getSystemService(
                  Context.NOTIFICATION_SERVICE);
          final Context context = mAm.mContext;
  
          if (active != null) {
              for (int i = 0; i < active.size(); i++) {
                  ActiveForegroundApp aa = active.get(i);
                  if (aa.mLabel == null) {
                      PackageManager pm = context.getPackageManager();
                      try {
                          ApplicationInfo ai = pm.getApplicationInfoAsUser(aa.mPackageName,
                                  PackageManager.MATCH_KNOWN_PACKAGES, smap.mUserId);
                          aa.mLabel = ai.loadLabel(pm);
                      } catch (PackageManager.NameNotFoundException e) {
                          aa.mLabel = aa.mPackageName;
                      }
                  }
              }
  
              Intent intent;
              String title;
              String msg;
              String[] pkgs;
              final long nowElapsed = SystemClock.elapsedRealtime();
              long oldestStartTime = nowElapsed;
              if (active.size() == 1) {
                  intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                  intent.setData(Uri.fromParts("package", active.get(0).mPackageName, null));
                  title = context.getString(
                          R.string.foreground_service_app_in_background, active.get(0).mLabel);
                  msg = context.getString(R.string.foreground_service_tap_for_details);
                  pkgs = new String[] { active.get(0).mPackageName };
                  oldestStartTime = active.get(0).mStartTime;
              } else {
                  intent = new Intent(Settings.ACTION_FOREGROUND_SERVICES_SETTINGS);
                  pkgs = new String[active.size()];
                  for (int i = 0; i < active.size(); i++) {
                      pkgs[i] = active.get(i).mPackageName;
                      oldestStartTime = Math.min(oldestStartTime, active.get(i).mStartTime);
                  }
                  intent.putExtra("packages", pkgs);
                  title = context.getString(
                          R.string.foreground_service_apps_in_background, active.size());
                  msg = active.get(0).mLabel.toString();
                  for (int i = 1; i < active.size(); i++) {
                      msg = context.getString(R.string.foreground_service_multiple_separator,
                              msg, active.get(i).mLabel);
                  }
              }
              Bundle notificationBundle = new Bundle();
              notificationBundle.putStringArray(Notification.EXTRA_FOREGROUND_APPS, pkgs);
              Notification.Builder n =
                      new Notification.Builder(context,
                              SystemNotificationChannels.FOREGROUND_SERVICE)
                              .addExtras(notificationBundle)
                              .setSmallIcon(R.drawable.stat_sys_vitals)
                              .setOngoing(true)
                              .setShowWhen(oldestStartTime < nowElapsed)
                              .setWhen(System.currentTimeMillis() - (nowElapsed - oldestStartTime))
                              .setColor(context.getColor(
                                      com.android.internal.R.color.system_notification_accent_color))
                              .setContentTitle(title)
                              .setContentText(msg)
                              .setContentIntent(
                                      PendingIntent.getActivityAsUser(context, 0, intent,
                                              PendingIntent.FLAG_UPDATE_CURRENT,
                                              null, new UserHandle(smap.mUserId)));
              nm.notifyAsUser(null, SystemMessageProto.SystemMessage.NOTE_FOREGROUND_SERVICES,
                      n.build(), new UserHandle(smap.mUserId));
          } else {
              nm.cancelAsUser(null, SystemMessageProto.SystemMessage.NOTE_FOREGROUND_SERVICES,
                      new UserHandle(smap.mUserId));
          }
      }
  
      private void requestUpdateActiveForegroundAppsLocked(ServiceMap smap, long timeElapsed) {
          Message msg = smap.obtainMessage(ServiceMap.MSG_UPDATE_FOREGROUND_APPS);
          if (timeElapsed != 0) {
              smap.sendMessageAtTime(msg,
                      timeElapsed + SystemClock.uptimeMillis() - SystemClock.elapsedRealtime());
          } else {
              smap.mActiveForegroundAppsChanged = true;
              smap.sendMessage(msg);
          }
      }
  
      private void decActiveForegroundAppLocked(ServiceMap smap, ServiceRecord r) {
          ActiveForegroundApp active = smap.mActiveForegroundApps.get(r.packageName);
          if (active != null) {
              active.mNumActive--;
              if (active.mNumActive <= 0) {
                  active.mEndTime = SystemClock.elapsedRealtime();
                  if (DEBUG_FOREGROUND_SERVICE) Slog.d(TAG, "Ended running of service");
                  if (foregroundAppShownEnoughLocked(active, active.mEndTime)) {
                      // Have been active for long enough that we will remove it immediately.
                      smap.mActiveForegroundApps.remove(r.packageName);
                      smap.mActiveForegroundAppsChanged = true;
                      requestUpdateActiveForegroundAppsLocked(smap, 0);
                  } else if (active.mHideTime < Long.MAX_VALUE){
                      requestUpdateActiveForegroundAppsLocked(smap, active.mHideTime);
                  }
              }
          }
      }
  
      void updateScreenStateLocked(boolean screenOn) {
          if (mScreenOn != screenOn) {
              mScreenOn = screenOn;
  
              // If screen is turning on, then we now reset the start time of any foreground
              // services that were started while the screen was off.
              if (screenOn) {
                  final long nowElapsed = SystemClock.elapsedRealtime();
                  if (DEBUG_FOREGROUND_SERVICE) Slog.d(TAG, "Screen turned on");
                  for (int i = mServiceMap.size()-1; i >= 0; i--) {
                      ServiceMap smap = mServiceMap.valueAt(i);
                      long nextUpdateTime = Long.MAX_VALUE;
                      boolean changed = false;
                      for (int j = smap.mActiveForegroundApps.size()-1; j >= 0; j--) {
                          ActiveForegroundApp active = smap.mActiveForegroundApps.valueAt(j);
                          if (active.mEndTime == 0) {
                              if (!active.mShownWhileScreenOn) {
                                  active.mShownWhileScreenOn = true;
                                  active.mStartVisibleTime = nowElapsed;
                              }
                          } else {
                              if (!active.mShownWhileScreenOn
                                      && active.mStartVisibleTime == active.mStartTime) {
                                  // If this was never shown while the screen was on, then we will
                                  // count the time it started being visible as now, to tell the user
                                  // about it now that they have a screen to look at.
                                  active.mEndTime = active.mStartVisibleTime = nowElapsed;
                              }
                              if (foregroundAppShownEnoughLocked(active, nowElapsed)) {
                                  // Have been active for long enough that we will remove it
                                  // immediately.
                                  smap.mActiveForegroundApps.remove(active.mPackageName);
                                  smap.mActiveForegroundAppsChanged = true;
                                  changed = true;
                              } else {
                                  if (active.mHideTime < nextUpdateTime) {
                                      nextUpdateTime = active.mHideTime;
                                  }
                              }
                          }
                      }
                      if (changed) {
                          // Need to immediately update.
                          requestUpdateActiveForegroundAppsLocked(smap, 0);
                      } else if (nextUpdateTime < Long.MAX_VALUE) {
                          requestUpdateActiveForegroundAppsLocked(smap, nextUpdateTime);
                      }
                  }
              }
          }
      }
  
      void foregroundServiceProcStateChangedLocked(UidRecord uidRec) {
          ServiceMap smap = mServiceMap.get(UserHandle.getUserId(uidRec.uid));
          if (smap != null) {
              boolean changed = false;
              for (int j = smap.mActiveForegroundApps.size()-1; j >= 0; j--) {
                  ActiveForegroundApp active = smap.mActiveForegroundApps.valueAt(j);
                  if (active.mUid == uidRec.uid) {
                      if (uidRec.getCurProcState() <= ActivityManager.PROCESS_STATE_TOP) {
                          if (!active.mAppOnTop) {
                              active.mAppOnTop = true;
                              changed = true;
                          }
                          active.mShownWhileTop = true;
                      } else if (active.mAppOnTop) {
                          active.mAppOnTop = false;
                          changed = true;
                      }
                  }
              }
              if (changed) {
                  requestUpdateActiveForegroundAppsLocked(smap, 0);
              }
          }
      }
  
      private boolean appIsTopLocked(int uid) {
          return mAm.getUidState(uid) <= ActivityManager.PROCESS_STATE_TOP;
      }
  
      /**
       * @param id Notification ID.  Zero === exit foreground state for the given service.
       */
      private void setServiceForegroundInnerLocked(final ServiceRecord r, int id,
              Notification notification, int flags, int foregroundServiceType) {
          if (id != 0) {
              if (notification == null) {
                  throw new IllegalArgumentException("null notification");
              }
              // Instant apps need permission to create foreground services.
              if (r.appInfo.isInstantApp()) {
                  final int mode = mAm.mAppOpsService.checkOperation(
                          AppOpsManager.OP_INSTANT_APP_START_FOREGROUND,
                          r.appInfo.uid,
                          r.appInfo.packageName);
                  switch (mode) {
                      case AppOpsManager.MODE_ALLOWED:
                          break;
                      case AppOpsManager.MODE_IGNORED:
                          Slog.w(TAG, "Instant app " + r.appInfo.packageName
                                  + " does not have permission to create foreground services"
                                  + ", ignoring.");
                          return;
                      case AppOpsManager.MODE_ERRORED:
                          throw new SecurityException("Instant app " + r.appInfo.packageName
                                  + " does not have permission to create foreground services");
                      default:
                          mAm.enforcePermission(
                                  android.Manifest.permission.INSTANT_APP_FOREGROUND_SERVICE,
                                  r.app.pid, r.appInfo.uid, "startForeground");
                  }
              } else {
                  if (r.appInfo.targetSdkVersion >= Build.VERSION_CODES.P) {
                      mAm.enforcePermission(
                              android.Manifest.permission.FOREGROUND_SERVICE,
                              r.app.pid, r.appInfo.uid, "startForeground");
                  }
  
                  int manifestType = r.serviceInfo.getForegroundServiceType();
                  // If passed in foreground service type is FOREGROUND_SERVICE_TYPE_MANIFEST,
                  // consider it is the same as manifest foreground service type.
                  if (foregroundServiceType == FOREGROUND_SERVICE_TYPE_MANIFEST) {
                      foregroundServiceType = manifestType;
                  }
                  // Check the passed in foreground service type flags is a subset of manifest
                  // foreground service type flags.
                  if ((foregroundServiceType & manifestType) != foregroundServiceType) {
                      throw new IllegalArgumentException("foregroundServiceType "
                          + String.format("0x%08X", foregroundServiceType)
                          + " is not a subset of foregroundServiceType attribute "
                          +  String.format("0x%08X", manifestType)
                          + " in service element of manifest file");
                  }
              }
              boolean alreadyStartedOp = false;
              boolean stopProcStatsOp = false;
              if (r.fgRequired) {
                  if (DEBUG_SERVICE || DEBUG_BACKGROUND_CHECK) {
                      Slog.i(TAG, "Service called startForeground() as required: " + r);
                  }
                  r.fgRequired = false;
                  r.fgWaiting = false;
                  alreadyStartedOp = stopProcStatsOp = true;
                  mAm.mHandler.removeMessages(
                          ActivityManagerService.SERVICE_FOREGROUND_TIMEOUT_MSG, r);
              }
  
              try {
                  boolean ignoreForeground = false;
                  final int mode = mAm.mAppOpsService.checkOperation(
                          AppOpsManager.OP_START_FOREGROUND, r.appInfo.uid, r.packageName);
                  switch (mode) {
                      case AppOpsManager.MODE_ALLOWED:
                      case AppOpsManager.MODE_DEFAULT:
                          // All okay.
                          break;
                      case AppOpsManager.MODE_IGNORED:
                          // Whoops, silently ignore this.
                          Slog.w(TAG, "Service.startForeground() not allowed due to app op: service "
                                  + r.shortInstanceName);
                          ignoreForeground = true;
                          break;
                      default:
                          throw new SecurityException("Foreground not allowed as per app op");
                  }
  
                  // Apps that are TOP or effectively similar may call startForeground() on
                  // their services even if they are restricted from doing that while in bg.
                  if (!ignoreForeground
                          && !appIsTopLocked(r.appInfo.uid)
                          && appRestrictedAnyInBackground(r.appInfo.uid, r.packageName)) {
                      Slog.w(TAG,
                              "Service.startForeground() not allowed due to bg restriction: service "
                              + r.shortInstanceName);
                      // Back off of any foreground expectations around this service, since we've
                      // just turned down its fg request.
                      updateServiceForegroundLocked(r.app, false);
                      ignoreForeground = true;
                  }
  
                  // Apps under strict background restrictions simply don't get to have foreground
                  // services, so now that we've enforced the startForegroundService() contract
                  // we only do the machinery of making the service foreground when the app
                  // is not restricted.
                  if (!ignoreForeground) {
                      if (r.foregroundId != id) {
                          cancelForegroundNotificationLocked(r);
                          r.foregroundId = id;
                      }
                      notification.flags |= Notification.FLAG_FOREGROUND_SERVICE;
                      r.foregroundNoti = notification;
                      r.foregroundServiceType = foregroundServiceType;
                      if (!r.isForeground) {
                          final ServiceMap smap = getServiceMapLocked(r.userId);
                          if (smap != null) {
                              ActiveForegroundApp active = smap.mActiveForegroundApps
                                      .get(r.packageName);
                              if (active == null) {
                                  active = new ActiveForegroundApp();
                                  active.mPackageName = r.packageName;
                                  active.mUid = r.appInfo.uid;
                                  active.mShownWhileScreenOn = mScreenOn;
                                  if (r.app != null) {
                                      active.mAppOnTop = active.mShownWhileTop =
                                              r.app.uidRecord.getCurProcState()
                                                      <= ActivityManager.PROCESS_STATE_TOP;
                                  }
                                  active.mStartTime = active.mStartVisibleTime
                                          = SystemClock.elapsedRealtime();
                                  smap.mActiveForegroundApps.put(r.packageName, active);
                                  requestUpdateActiveForegroundAppsLocked(smap, 0);
                              }
                              active.mNumActive++;
                          }
                          r.isForeground = true;
                          if (!stopProcStatsOp) {
                              ServiceState stracker = r.getTracker();
                              if (stracker != null) {
                                  stracker.setForeground(true,
                                          mAm.mProcessStats.getMemFactorLocked(), r.lastActivity);
                              }
                          } else {
                              stopProcStatsOp = false;
                          }
                          mAm.mAppOpsService.startOperation(
                                  AppOpsManager.getToken(mAm.mAppOpsService),
                                  AppOpsManager.OP_START_FOREGROUND, r.appInfo.uid, r.packageName,
                                  true);
                          StatsLog.write(StatsLog.FOREGROUND_SERVICE_STATE_CHANGED,
                                  r.appInfo.uid, r.shortInstanceName,
                                  StatsLog.FOREGROUND_SERVICE_STATE_CHANGED__STATE__ENTER);
                          mAm.updateForegroundServiceUsageStats(r.name, r.userId, true);
                      }
                      r.postNotification();
                      if (r.app != null) {
                          updateServiceForegroundLocked(r.app, true);
                      }
                      getServiceMapLocked(r.userId).ensureNotStartingBackgroundLocked(r);
                      mAm.notifyPackageUse(r.serviceInfo.packageName,
                              PackageManager.NOTIFY_PACKAGE_USE_FOREGROUND_SERVICE);
                  } else {
                      if (DEBUG_FOREGROUND_SERVICE) {
                          Slog.d(TAG, "Suppressing startForeground() for FAS " + r);
                      }
                  }
              } finally {
                  if (stopProcStatsOp) {
                      // We got through to this point with it actively being started foreground,
                      // and never decided we wanted to keep it like that, so drop it.
                      ServiceState stracker = r.getTracker();
                      if (stracker != null) {
                          stracker.setForeground(false, mAm.mProcessStats.getMemFactorLocked(),
                                  r.lastActivity);
                      }
                  }
                  if (alreadyStartedOp) {
                      // If we had previously done a start op for direct foreground start,
                      // we have cleared the flag so can now drop it.
                      mAm.mAppOpsService.finishOperation(
                              AppOpsManager.getToken(mAm.mAppOpsService),
                              AppOpsManager.OP_START_FOREGROUND, r.appInfo.uid, r.packageName);
                  }
              }
          } else {
              if (r.isForeground) {
                  final ServiceMap smap = getServiceMapLocked(r.userId);
                  if (smap != null) {
                      decActiveForegroundAppLocked(smap, r);
                  }
                  r.isForeground = false;
                  ServiceState stracker = r.getTracker();
                  if (stracker != null) {
                      stracker.setForeground(false, mAm.mProcessStats.getMemFactorLocked(),
                              r.lastActivity);
                  }
                  mAm.mAppOpsService.finishOperation(
                          AppOpsManager.getToken(mAm.mAppOpsService),
                          AppOpsManager.OP_START_FOREGROUND, r.appInfo.uid, r.packageName);
                  StatsLog.write(StatsLog.FOREGROUND_SERVICE_STATE_CHANGED,
                          r.appInfo.uid, r.shortInstanceName,
                          StatsLog.FOREGROUND_SERVICE_STATE_CHANGED__STATE__EXIT);
                  mAm.updateForegroundServiceUsageStats(r.name, r.userId, false);
                  if (r.app != null) {
                      mAm.updateLruProcessLocked(r.app, false, null);
                      updateServiceForegroundLocked(r.app, true);
                  }
              }
              if ((flags & Service.STOP_FOREGROUND_REMOVE) != 0) {
                  cancelForegroundNotificationLocked(r);
                  r.foregroundId = 0;
                  r.foregroundNoti = null;
              } else if (r.appInfo.targetSdkVersion >= Build.VERSION_CODES.LOLLIPOP) {
                  r.stripForegroundServiceFlagFromNotification();
                  if ((flags & Service.STOP_FOREGROUND_DETACH) != 0) {
                      r.foregroundId = 0;
                      r.foregroundNoti = null;
                  }
              }
          }
      }
  
      private void cancelForegroundNotificationLocked(ServiceRecord r) {
          if (r.foregroundId != 0) {
              // First check to see if this app has any other active foreground services
              // with the same notification ID.  If so, we shouldn't actually cancel it,
              // because that would wipe away the notification that still needs to be shown
              // due the other service.
              ServiceMap sm = getServiceMapLocked(r.userId);
              if (sm != null) {
                  for (int i = sm.mServicesByInstanceName.size() - 1; i >= 0; i--) {
                      ServiceRecord other = sm.mServicesByInstanceName.valueAt(i);
                      if (other != r && other.foregroundId == r.foregroundId
                              && other.packageName.equals(r.packageName)) {
                          // Found one!  Abort the cancel.
                          return;
                      }
                  }
              }
              r.cancelNotification();
          }
      }
  
      private void updateServiceForegroundLocked(ProcessRecord proc, boolean oomAdj) {
          boolean anyForeground = false;
          int fgServiceTypes = 0;
          for (int i = proc.services.size() - 1; i >= 0; i--) {
              ServiceRecord sr = proc.services.valueAt(i);
              if (sr.isForeground || sr.fgRequired) {
                  anyForeground = true;
                  fgServiceTypes |= sr.foregroundServiceType;
              }
          }
          mAm.updateProcessForegroundLocked(proc, anyForeground, fgServiceTypes, oomAdj);
      }
  
      private void updateWhitelistManagerLocked(ProcessRecord proc) {
          proc.whitelistManager = false;
          for (int i=proc.services.size()-1; i>=0; i--) {
              ServiceRecord sr = proc.services.valueAt(i);
              if (sr.whitelistManager) {
                  proc.whitelistManager = true;
                  break;
              }
          }
      }
  
      public void updateServiceConnectionActivitiesLocked(ProcessRecord clientProc) {
          ArraySet<ProcessRecord> updatedProcesses = null;
          for (int i = 0; i < clientProc.connections.size(); i++) {
              final ConnectionRecord conn = clientProc.connections.valueAt(i);
              final ProcessRecord proc = conn.binding.service.app;
              if (proc == null || proc == clientProc) {
                  continue;
              } else if (updatedProcesses == null) {
                  updatedProcesses = new ArraySet<>();
              } else if (updatedProcesses.contains(proc)) {
                  continue;
              }
              updatedProcesses.add(proc);
              updateServiceClientActivitiesLocked(proc, null, false);
          }
      }
  
      private boolean updateServiceClientActivitiesLocked(ProcessRecord proc,
              ConnectionRecord modCr, boolean updateLru) {
          if (modCr != null && modCr.binding.client != null) {
              if (!modCr.binding.client.hasActivities()) {
                  // This connection is from a client without activities, so adding
                  // and removing is not interesting.
                  return false;
              }
          }
  
          boolean anyClientActivities = false;
          for (int i=proc.services.size()-1; i>=0 && !anyClientActivities; i--) {
              ServiceRecord sr = proc.services.valueAt(i);
              ArrayMap<IBinder, ArrayList<ConnectionRecord>> connections = sr.getConnections();
              for (int conni = connections.size() - 1; conni >= 0 && !anyClientActivities; conni--) {
                  ArrayList<ConnectionRecord> clist = connections.valueAt(conni);
                  for (int cri=clist.size()-1; cri>=0; cri--) {
                      ConnectionRecord cr = clist.get(cri);
                      if (cr.binding.client == null || cr.binding.client == proc) {
                          // Binding to ourself is not interesting.
                          continue;
                      }
                      if (cr.binding.client.hasActivities()) {
                          anyClientActivities = true;
                          break;
                      }
                  }
              }
          }
          if (anyClientActivities != proc.hasClientActivities()) {
              proc.setHasClientActivities(anyClientActivities);
              if (updateLru) {
                  mAm.updateLruProcessLocked(proc, anyClientActivities, null);
              }
              return true;
          }
          return false;
      }
  
      int bindServiceLocked(IApplicationThread caller, IBinder token, Intent service,
              String resolvedType, final IServiceConnection connection, int flags,
              String instanceName, String callingPackage, final int userId)
              throws TransactionTooLargeException {
          if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "bindService: " + service
                  + " type=" + resolvedType + " conn=" + connection.asBinder()
                  + " flags=0x" + Integer.toHexString(flags));
          final ProcessRecord callerApp = mAm.getRecordForAppLocked(caller);
          if (callerApp == null) {
              throw new SecurityException(
                      "Unable to find app for caller " + caller
                      + " (pid=" + Binder.getCallingPid()
                      + ") when binding service " + service);
          }
  
          ActivityServiceConnectionsHolder<ConnectionRecord> activity = null;
          if (token != null) {
              activity = mAm.mAtmInternal.getServiceConnectionsHolder(token);
              if (activity == null) {
                  Slog.w(TAG, "Binding with unknown activity: " + token);
                  return 0;
              }
          }
  
          int clientLabel = 0;
          PendingIntent clientIntent = null;
          final boolean isCallerSystem = callerApp.info.uid == Process.SYSTEM_UID;
  
          if (isCallerSystem) {
              // Hacky kind of thing -- allow system stuff to tell us
              // what they are, so we can report this elsewhere for
              // others to know why certain services are running.
              service.setDefusable(true);
              clientIntent = service.getParcelableExtra(Intent.EXTRA_CLIENT_INTENT);
              if (clientIntent != null) {
                  clientLabel = service.getIntExtra(Intent.EXTRA_CLIENT_LABEL, 0);
                  if (clientLabel != 0) {
                      // There are no useful extras in the intent, trash them.
                      // System code calling with this stuff just needs to know
                      // this will happen.
                      service = service.cloneFilter();
                  }
              }
          }
  
          if ((flags&Context.BIND_TREAT_LIKE_ACTIVITY) != 0) {
              mAm.enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS,
                      "BIND_TREAT_LIKE_ACTIVITY");
          }
  
          if ((flags & Context.BIND_SCHEDULE_LIKE_TOP_APP) != 0 && !isCallerSystem) {
              throw new SecurityException("Non-system caller (pid=" + Binder.getCallingPid()
                      + ") set BIND_SCHEDULE_LIKE_TOP_APP when binding service " + service);
          }
  
          if ((flags & Context.BIND_ALLOW_WHITELIST_MANAGEMENT) != 0 && !isCallerSystem) {
              throw new SecurityException(
                      "Non-system caller " + caller + " (pid=" + Binder.getCallingPid()
                      + ") set BIND_ALLOW_WHITELIST_MANAGEMENT when binding service " + service);
          }
  
          if ((flags & Context.BIND_ALLOW_INSTANT) != 0 && !isCallerSystem) {
              throw new SecurityException(
                      "Non-system caller " + caller + " (pid=" + Binder.getCallingPid()
                              + ") set BIND_ALLOW_INSTANT when binding service " + service);
          }
  
          if ((flags & Context.BIND_ALLOW_BACKGROUND_ACTIVITY_STARTS) != 0) {
              mAm.enforceCallingPermission(
                      android.Manifest.permission.START_ACTIVITIES_FROM_BACKGROUND,
                      "BIND_ALLOW_BACKGROUND_ACTIVITY_STARTS");
          }
  
          final boolean callerFg = callerApp.setSchedGroup != ProcessList.SCHED_GROUP_BACKGROUND;
          final boolean isBindExternal = (flags & Context.BIND_EXTERNAL_SERVICE) != 0;
          final boolean allowInstant = (flags & Context.BIND_ALLOW_INSTANT) != 0;
  
          ServiceLookupResult res =
              retrieveServiceLocked(service, instanceName, resolvedType, callingPackage,
                      Binder.getCallingPid(), Binder.getCallingUid(), userId, true,
                      callerFg, isBindExternal, allowInstant);
          if (res == null) {
              return 0;
          }
          if (res.record == null) {
              return -1;
          }
          ServiceRecord s = res.record;
  
          boolean permissionsReviewRequired = false;
  
          // If permissions need a review before any of the app components can run,
          // we schedule binding to the service but do not start its process, then
          // we launch a review activity to which is passed a callback to invoke
          // when done to start the bound service's process to completing the binding.
          if (mAm.getPackageManagerInternalLocked().isPermissionsReviewRequired(
                  s.packageName, s.userId)) {
  
              permissionsReviewRequired = true;
  
              // Show a permission review UI only for binding from a foreground app
              if (!callerFg) {
                  Slog.w(TAG, "u" + s.userId + " Binding to a service in package"
                          + s.packageName + " requires a permissions review");
                  return 0;
              }
  
              final ServiceRecord serviceRecord = s;
              final Intent serviceIntent = service;
  
              RemoteCallback callback = new RemoteCallback(
                      new RemoteCallback.OnResultListener() {
                  @Override
                  public void onResult(Bundle result) {
                      synchronized(mAm) {
                          final long identity = Binder.clearCallingIdentity();
                          try {
                              if (!mPendingServices.contains(serviceRecord)) {
                                  return;
                              }
                              // If there is still a pending record, then the service
                              // binding request is still valid, so hook them up. We
                              // proceed only if the caller cleared the review requirement
                              // otherwise we unbind because the user didn't approve.
                              if (!mAm.getPackageManagerInternalLocked()
                                      .isPermissionsReviewRequired(
                                              serviceRecord.packageName,
                                              serviceRecord.userId)) {
                                  try {
                                      bringUpServiceLocked(serviceRecord,
                                              serviceIntent.getFlags(),
                                              callerFg, false, false);
                                  } catch (RemoteException e) {
                                      /* ignore - local call */
                                  }
                              } else {
                                  unbindServiceLocked(connection);
                              }
                          } finally {
                              Binder.restoreCallingIdentity(identity);
                          }
                      }
                  }
              });
  
              final Intent intent = new Intent(Intent.ACTION_REVIEW_PERMISSIONS);
              intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                      | Intent.FLAG_ACTIVITY_MULTIPLE_TASK
                      | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
              intent.putExtra(Intent.EXTRA_PACKAGE_NAME, s.packageName);
              intent.putExtra(Intent.EXTRA_REMOTE_CALLBACK, callback);
  
              if (DEBUG_PERMISSIONS_REVIEW) {
                  Slog.i(TAG, "u" + s.userId + " Launching permission review for package "
                          + s.packageName);
              }
  
              mAm.mHandler.post(new Runnable() {
                  @Override
                  public void run() {
                      mAm.mContext.startActivityAsUser(intent, new UserHandle(userId));
                  }
              });
          }
  
          final long origId = Binder.clearCallingIdentity();
  
          try {
              if (unscheduleServiceRestartLocked(s, callerApp.info.uid, false)) {
                  if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "BIND SERVICE WHILE RESTART PENDING: "
                          + s);
              }
  
              if ((flags&Context.BIND_AUTO_CREATE) != 0) {
                  s.lastActivity = SystemClock.uptimeMillis();
                  if (!s.hasAutoCreateConnections()) {
                      // This is the first binding, let the tracker know.
                      ServiceState stracker = s.getTracker();
                      if (stracker != null) {
                          stracker.setBound(true, mAm.mProcessStats.getMemFactorLocked(),
                                  s.lastActivity);
                      }
                  }
              }
  
              if ((flags & Context.BIND_RESTRICT_ASSOCIATIONS) != 0) {
                  mAm.requireAllowedAssociationsLocked(s.appInfo.packageName);
              }
  
              mAm.startAssociationLocked(callerApp.uid, callerApp.processName,
                      callerApp.getCurProcState(), s.appInfo.uid, s.appInfo.longVersionCode,
                      s.instanceName, s.processName);
              // Once the apps have become associated, if one of them is caller is ephemeral
              // the target app should now be able to see the calling app
              mAm.grantEphemeralAccessLocked(callerApp.userId, service,
                      UserHandle.getAppId(s.appInfo.uid), UserHandle.getAppId(callerApp.uid));
  
              AppBindRecord b = s.retrieveAppBindingLocked(service, callerApp);
              ConnectionRecord c = new ConnectionRecord(b, activity,
                      connection, flags, clientLabel, clientIntent,
                      callerApp.uid, callerApp.processName, callingPackage);
  
              IBinder binder = connection.asBinder();
              s.addConnection(binder, c);
              b.connections.add(c);
              if (activity != null) {
                  activity.addConnection(c);
              }
              b.client.connections.add(c);
              c.startAssociationIfNeeded();
              if ((c.flags&Context.BIND_ABOVE_CLIENT) != 0) {
                  b.client.hasAboveClient = true;
              }
              if ((c.flags&Context.BIND_ALLOW_WHITELIST_MANAGEMENT) != 0) {
                  s.whitelistManager = true;
              }
              if ((flags & Context.BIND_ALLOW_BACKGROUND_ACTIVITY_STARTS) != 0) {
                  s.setHasBindingWhitelistingBgActivityStarts(true);
              }
              if (s.app != null) {
                  updateServiceClientActivitiesLocked(s.app, c, true);
              }
              ArrayList<ConnectionRecord> clist = mServiceConnections.get(binder);
              if (clist == null) {
                  clist = new ArrayList<>();
                  mServiceConnections.put(binder, clist);
              }
              clist.add(c);
  
              if ((flags&Context.BIND_AUTO_CREATE) != 0) {
                  s.lastActivity = SystemClock.uptimeMillis();
                  if (bringUpServiceLocked(s, service.getFlags(), callerFg, false,
                          permissionsReviewRequired) != null) {
                      return 0;
                  }
              }
  
              if (s.app != null) {
                  if ((flags&Context.BIND_TREAT_LIKE_ACTIVITY) != 0) {
                      s.app.treatLikeActivity = true;
                  }
                  if (s.whitelistManager) {
                      s.app.whitelistManager = true;
                  }
                  // This could have made the service more important.
                  mAm.updateLruProcessLocked(s.app,
                          (callerApp.hasActivitiesOrRecentTasks() && s.app.hasClientActivities())
                                  || (callerApp.getCurProcState() <= ActivityManager.PROCESS_STATE_TOP
                                          && (flags & Context.BIND_TREAT_LIKE_ACTIVITY) != 0),
                          b.client);
                  mAm.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_BIND_SERVICE);
              }
  
              if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Bind " + s + " with " + b
                      + ": received=" + b.intent.received
                      + " apps=" + b.intent.apps.size()
                      + " doRebind=" + b.intent.doRebind);
  
              if (s.app != null && b.intent.received) {
                  // Service is already running, so we can immediately
                  // publish the connection.
                  try {
                      c.conn.connected(s.name, b.intent.binder, false);
                  } catch (Exception e) {
                      Slog.w(TAG, "Failure sending service " + s.shortInstanceName
                              + " to connection " + c.conn.asBinder()
                              + " (in " + c.binding.client.processName + ")", e);
                  }
  
                  // If this is the first app connected back to this binding,
                  // and the service had previously asked to be told when
                  // rebound, then do so.
                  if (b.intent.apps.size() == 1 && b.intent.doRebind) {
                      requestServiceBindingLocked(s, b.intent, callerFg, true);
                  }
              } else if (!b.intent.requested) {
                  requestServiceBindingLocked(s, b.intent, callerFg, false);
              }
  
              getServiceMapLocked(s.userId).ensureNotStartingBackgroundLocked(s);
  
          } finally {
              Binder.restoreCallingIdentity(origId);
          }
  
          return 1;
      }
  
      void publishServiceLocked(ServiceRecord r, Intent intent, IBinder service) {
          final long origId = Binder.clearCallingIdentity();
          try {
              if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "PUBLISHING " + r
                      + " " + intent + ": " + service);
              if (r != null) {
                  Intent.FilterComparison filter
                          = new Intent.FilterComparison(intent);
                  IntentBindRecord b = r.bindings.get(filter);
                  if (b != null && !b.received) {
                      b.binder = service;
                      b.requested = true;
                      b.received = true;
                      ArrayMap<IBinder, ArrayList<ConnectionRecord>> connections = r.getConnections();
                      for (int conni = connections.size() - 1; conni >= 0; conni--) {
                          ArrayList<ConnectionRecord> clist = connections.valueAt(conni);
                          for (int i=0; i<clist.size(); i++) {
                              ConnectionRecord c = clist.get(i);
                              if (!filter.equals(c.binding.intent.intent)) {
                                  if (DEBUG_SERVICE) Slog.v(
                                          TAG_SERVICE, "Not publishing to: " + c);
                                  if (DEBUG_SERVICE) Slog.v(
                                          TAG_SERVICE, "Bound intent: " + c.binding.intent.intent);
                                  if (DEBUG_SERVICE) Slog.v(
                                          TAG_SERVICE, "Published intent: " + intent);
                                  continue;
                              }
                              if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Publishing to: " + c);
                              try {
                                  c.conn.connected(r.name, service, false);
                              } catch (Exception e) {
                                  Slog.w(TAG, "Failure sending service " + r.shortInstanceName
                                        + " to connection " + c.conn.asBinder()
                                        + " (in " + c.binding.client.processName + ")", e);
                              }
                          }
                      }
                  }
  
                  serviceDoneExecutingLocked(r, mDestroyingServices.contains(r), false);
              }
          } finally {
              Binder.restoreCallingIdentity(origId);
          }
      }
  
      void updateServiceGroupLocked(IServiceConnection connection, int group, int importance) {
          final IBinder binder = connection.asBinder();
          if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "updateServiceGroup: conn=" + binder);
          final ArrayList<ConnectionRecord> clist = mServiceConnections.get(binder);
          if (clist == null) {
              throw new IllegalArgumentException("Could not find connection for "
                      + connection.asBinder());
          }
          for (int i = clist.size() - 1; i >= 0; i--) {
              final ConnectionRecord crec = clist.get(i);
              final ServiceRecord srec = crec.binding.service;
              if (srec != null && (srec.serviceInfo.flags & ServiceInfo.FLAG_ISOLATED_PROCESS) != 0) {
                  if (srec.app != null) {
                      if (group > 0) {
                          srec.app.connectionService = srec;
                          srec.app.connectionGroup = group;
                          srec.app.connectionImportance = importance;
                      } else {
                          srec.app.connectionService = null;
                          srec.app.connectionGroup = 0;
                          srec.app.connectionImportance = 0;
                      }
                  } else {
                      if (group > 0) {
                          srec.pendingConnectionGroup = group;
                          srec.pendingConnectionImportance = importance;
                      } else {
                          srec.pendingConnectionGroup = 0;
                          srec.pendingConnectionImportance = 0;
                      }
                  }
              }
          }
      }
  
      boolean unbindServiceLocked(IServiceConnection connection) {
          IBinder binder = connection.asBinder();
          if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "unbindService: conn=" + binder);
          ArrayList<ConnectionRecord> clist = mServiceConnections.get(binder);
          if (clist == null) {
              Slog.w(TAG, "Unbind failed: could not find connection for "
                    + connection.asBinder());
              return false;
          }
  
          final long origId = Binder.clearCallingIdentity();
          try {
              while (clist.size() > 0) {
                  ConnectionRecord r = clist.get(0);
                  removeConnectionLocked(r, null, null);
                  if (clist.size() > 0 && clist.get(0) == r) {
                      // In case it didn't get removed above, do it now.
                      Slog.wtf(TAG, "Connection " + r + " not removed for binder " + binder);
                      clist.remove(0);
                  }
  
                  if (r.binding.service.app != null) {
                      if (r.binding.service.app.whitelistManager) {
                          updateWhitelistManagerLocked(r.binding.service.app);
                      }
                      // This could have made the service less important.
                      if ((r.flags&Context.BIND_TREAT_LIKE_ACTIVITY) != 0) {
                          r.binding.service.app.treatLikeActivity = true;
                          mAm.updateLruProcessLocked(r.binding.service.app,
                                  r.binding.service.app.hasClientActivities()
                                  || r.binding.service.app.treatLikeActivity, null);
                      }
                  }
              }
  
              mAm.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_UNBIND_SERVICE);
  
          } finally {
              Binder.restoreCallingIdentity(origId);
          }
  
          return true;
      }
  
      void unbindFinishedLocked(ServiceRecord r, Intent intent, boolean doRebind) {
          final long origId = Binder.clearCallingIdentity();
          try {
              if (r != null) {
                  Intent.FilterComparison filter
                          = new Intent.FilterComparison(intent);
                  IntentBindRecord b = r.bindings.get(filter);
                  if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "unbindFinished in " + r
                          + " at " + b + ": apps="
                          + (b != null ? b.apps.size() : 0));
  
                  boolean inDestroying = mDestroyingServices.contains(r);
                  if (b != null) {
                      if (b.apps.size() > 0 && !inDestroying) {
                          // Applications have already bound since the last
                          // unbind, so just rebind right here.
                          boolean inFg = false;
                          for (int i=b.apps.size()-1; i>=0; i--) {
                              ProcessRecord client = b.apps.valueAt(i).client;
                              if (client != null && client.setSchedGroup
                                      != ProcessList.SCHED_GROUP_BACKGROUND) {
                                  inFg = true;
                                  break;
                              }
                          }
                          try {
                              requestServiceBindingLocked(r, b, inFg, true);
                          } catch (TransactionTooLargeException e) {
                              // Don't pass this back to ActivityThread, it's unrelated.
                          }
                      } else {
                          // Note to tell the service the next time there is
                          // a new client.
                          b.doRebind = true;
                      }
                  }
  
                  serviceDoneExecutingLocked(r, inDestroying, false);
              }
          } finally {
              Binder.restoreCallingIdentity(origId);
          }
      }
  
      private final ServiceRecord findServiceLocked(ComponentName name,
              IBinder token, int userId) {
          ServiceRecord r = getServiceByNameLocked(name, userId);
          return r == token ? r : null;
      }
  
      private final class ServiceLookupResult {
          final ServiceRecord record;
          final String permission;
  
          ServiceLookupResult(ServiceRecord _record, String _permission) {
              record = _record;
              permission = _permission;
          }
      }
  
      private class ServiceRestarter implements Runnable {
          private ServiceRecord mService;
  
          void setService(ServiceRecord service) {
              mService = service;
          }
  
          public void run() {
              synchronized(mAm) {
                  performServiceRestartLocked(mService);
              }
          }
      }
  
      private ServiceLookupResult retrieveServiceLocked(Intent service,
              String instanceName, String resolvedType, String callingPackage,
              int callingPid, int callingUid, int userId,
              boolean createIfNeeded, boolean callingFromFg, boolean isBindExternal,
              boolean allowInstant) {
          ServiceRecord r = null;
          if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "retrieveServiceLocked: " + service
                  + " type=" + resolvedType + " callingUid=" + callingUid);
  
          userId = mAm.mUserController.handleIncomingUser(callingPid, callingUid, userId, false,
                  ActivityManagerInternal.ALLOW_NON_FULL_IN_PROFILE, "service",
                  callingPackage);
  
          ServiceMap smap = getServiceMapLocked(userId);
          final ComponentName comp;
          if (instanceName == null) {
              comp = service.getComponent();
          } else {
              final ComponentName realComp = service.getComponent();
              if (realComp == null) {
                  throw new IllegalArgumentException("Can't use custom instance name '" + instanceName
                          + "' without expicit component in Intent");
              }
              comp = new ComponentName(realComp.getPackageName(),
                      realComp.getClassName() + ":" + instanceName);
          }
          if (comp != null) {
              r = smap.mServicesByInstanceName.get(comp);
              if (DEBUG_SERVICE && r != null) Slog.v(TAG_SERVICE, "Retrieved by component: " + r);
          }
          if (r == null && !isBindExternal && instanceName == null) {
              Intent.FilterComparison filter = new Intent.FilterComparison(service);
              r = smap.mServicesByIntent.get(filter);
              if (DEBUG_SERVICE && r != null) Slog.v(TAG_SERVICE, "Retrieved by intent: " + r);
          }
          if (r != null && (r.serviceInfo.flags & ServiceInfo.FLAG_EXTERNAL_SERVICE) != 0
                  && !callingPackage.equals(r.packageName)) {
              // If an external service is running within its own package, other packages
              // should not bind to that instance.
              r = null;
              if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Whoops, can't use existing external service");
          }
          if (r == null) {
              try {
                  int flags = ActivityManagerService.STOCK_PM_FLAGS
                          | PackageManager.MATCH_DEBUG_TRIAGED_MISSING;
                  if (allowInstant) {
                      flags |= PackageManager.MATCH_INSTANT;
                  }
                  // TODO: come back and remove this assumption to triage all services
                  ResolveInfo rInfo = mAm.getPackageManagerInternalLocked().resolveService(service,
                          resolvedType, flags, userId, callingUid);
                  ServiceInfo sInfo = rInfo != null ? rInfo.serviceInfo : null;
                  if (sInfo == null) {
                      Slog.w(TAG_SERVICE, "Unable to start service " + service + " U=" + userId +
                            ": not found");
                      return null;
                  }
                  if (instanceName != null
                          && (sInfo.flags & ServiceInfo.FLAG_ISOLATED_PROCESS) == 0) {
                      throw new IllegalArgumentException("Can't use instance name '" + instanceName
                              + "' with non-isolated service '" + sInfo.name + "'");
                  }
                  ComponentName className = new ComponentName(
                          sInfo.applicationInfo.packageName, sInfo.name);
                  ComponentName name = comp != null ? comp : className;
                  if (!mAm.validateAssociationAllowedLocked(callingPackage, callingUid,
                          name.getPackageName(), sInfo.applicationInfo.uid)) {
                      String msg = "association not allowed between packages "
                              + callingPackage + " and " + name.getPackageName();
                      Slog.w(TAG, "Service lookup failed: " + msg);
                      return new ServiceLookupResult(null, msg);
                  }
  
                  // Store the defining packageName and uid, as they might be changed in
                  // the ApplicationInfo for external services (which run with the package name
                  // and uid of the caller).
                  String definingPackageName = sInfo.applicationInfo.packageName;
                  int definingUid = sInfo.applicationInfo.uid;
                  if ((sInfo.flags & ServiceInfo.FLAG_EXTERNAL_SERVICE) != 0) {
                      if (isBindExternal) {
                          if (!sInfo.exported) {
                              throw new SecurityException("BIND_EXTERNAL_SERVICE failed, "
                                      + className + " is not exported");
                          }
                          if ((sInfo.flags & ServiceInfo.FLAG_ISOLATED_PROCESS) == 0) {
                              throw new SecurityException("BIND_EXTERNAL_SERVICE failed, "
                                      + className + " is not an isolatedProcess");
                          }
                          // Run the service under the calling package's application.
                          ApplicationInfo aInfo = AppGlobals.getPackageManager().getApplicationInfo(
                                  callingPackage, ActivityManagerService.STOCK_PM_FLAGS, userId);
                          if (aInfo == null) {
                              throw new SecurityException("BIND_EXTERNAL_SERVICE failed, " +
                                      "could not resolve client package " + callingPackage);
                          }
                          sInfo = new ServiceInfo(sInfo);
                          sInfo.applicationInfo = new ApplicationInfo(sInfo.applicationInfo);
                          sInfo.applicationInfo.packageName = aInfo.packageName;
                          sInfo.applicationInfo.uid = aInfo.uid;
                          name = new ComponentName(aInfo.packageName, name.getClassName());
                          className = new ComponentName(aInfo.packageName,
                                  instanceName == null ? className.getClassName()
                                          : (className.getClassName() + ":" + instanceName));
                          service.setComponent(name);
                      } else {
                          throw new SecurityException("BIND_EXTERNAL_SERVICE required for " +
                                  name);
                      }
                  } else if (isBindExternal) {
                      throw new SecurityException("BIND_EXTERNAL_SERVICE failed, " + name +
                              " is not an externalService");
                  }
                  if (userId > 0) {
                      if (mAm.isSingleton(sInfo.processName, sInfo.applicationInfo,
                              sInfo.name, sInfo.flags)
                              && mAm.isValidSingletonCall(callingUid, sInfo.applicationInfo.uid)) {
                          userId = 0;
                          smap = getServiceMapLocked(0);
                      }
                      sInfo = new ServiceInfo(sInfo);
                      sInfo.applicationInfo = mAm.getAppInfoForUser(sInfo.applicationInfo, userId);
                  }
                  r = smap.mServicesByInstanceName.get(name);
                  if (DEBUG_SERVICE && r != null) Slog.v(TAG_SERVICE,
                          "Retrieved via pm by intent: " + r);
                  if (r == null && createIfNeeded) {
                      final Intent.FilterComparison filter
                              = new Intent.FilterComparison(service.cloneFilter());
                      final ServiceRestarter res = new ServiceRestarter();
                      final BatteryStatsImpl.Uid.Pkg.Serv ss;
                      final BatteryStatsImpl stats = mAm.mBatteryStatsService.getActiveStatistics();
                      synchronized (stats) {
                          ss = stats.getServiceStatsLocked(
                                  sInfo.applicationInfo.uid, name.getPackageName(),
                                  name.getClassName());
                      }
                      r = new ServiceRecord(mAm, ss, className, name, definingPackageName,
                              definingUid, filter, sInfo, callingFromFg, res);
                      res.setService(r);
                      smap.mServicesByInstanceName.put(name, r);
                      smap.mServicesByIntent.put(filter, r);
  
                      // Make sure this component isn't in the pending list.
                      for (int i=mPendingServices.size()-1; i>=0; i--) {
                          final ServiceRecord pr = mPendingServices.get(i);
                          if (pr.serviceInfo.applicationInfo.uid == sInfo.applicationInfo.uid
                                  && pr.instanceName.equals(name)) {
                              if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Remove pending: " + pr);
                              mPendingServices.remove(i);
                          }
                      }
                      if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Retrieve created new service: " + r);
                  }
              } catch (RemoteException ex) {
                  // pm is in same process, this will never happen.
              }
          }
          if (r != null) {
              if (!mAm.validateAssociationAllowedLocked(callingPackage, callingUid, r.packageName,
                      r.appInfo.uid)) {
                  String msg = "association not allowed between packages "
                          + callingPackage + " and " + r.packageName;
                  Slog.w(TAG, "Service lookup failed: " + msg);
                  return new ServiceLookupResult(null, msg);
              }
              if (!mAm.mIntentFirewall.checkService(r.name, service, callingUid, callingPid,
                      resolvedType, r.appInfo)) {
                  return new ServiceLookupResult(null, "blocked by firewall");
              }
              if (mAm.checkComponentPermission(r.permission,
                      callingPid, callingUid, r.appInfo.uid, r.exported) != PERMISSION_GRANTED) {
                  if (!r.exported) {
                      Slog.w(TAG, "Permission Denial: Accessing service " + r.shortInstanceName
                              + " from pid=" + callingPid
                              + ", uid=" + callingUid
                              + " that is not exported from uid " + r.appInfo.uid);
                      return new ServiceLookupResult(null, "not exported from uid "
                              + r.appInfo.uid);
                  }
                  Slog.w(TAG, "Permission Denial: Accessing service " + r.shortInstanceName
                          + " from pid=" + callingPid
                          + ", uid=" + callingUid
                          + " requires " + r.permission);
                  return new ServiceLookupResult(null, r.permission);
              } else if (r.permission != null && callingPackage != null) {
                  final int opCode = AppOpsManager.permissionToOpCode(r.permission);
                  if (opCode != AppOpsManager.OP_NONE && mAm.mAppOpsService.checkOperation(
                          opCode, callingUid, callingPackage) != AppOpsManager.MODE_ALLOWED) {
                      Slog.w(TAG, "Appop Denial: Accessing service " + r.shortInstanceName
                              + " from pid=" + callingPid
                              + ", uid=" + callingUid
                              + " requires appop " + AppOpsManager.opToName(opCode));
                      return null;
                  }
              }
              return new ServiceLookupResult(r, null);
          }
          return null;
      }
  
      private final void bumpServiceExecutingLocked(ServiceRecord r, boolean fg, String why) {
          if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, ">>> EXECUTING "
                  + why + " of " + r + " in app " + r.app);
          else if (DEBUG_SERVICE_EXECUTING) Slog.v(TAG_SERVICE_EXECUTING, ">>> EXECUTING "
                  + why + " of " + r.shortInstanceName);
  
          // For b/34123235: Services within the system server won't start until SystemServer
          // does Looper.loop(), so we shouldn't try to start/bind to them too early in the boot
          // process. However, since there's a little point of showing the ANR dialog in that case,
          // let's suppress the timeout until PHASE_THIRD_PARTY_APPS_CAN_START.
          //
          // (Note there are multiple services start at PHASE_THIRD_PARTY_APPS_CAN_START too,
          // which technically could also trigger this timeout if there's a system server
          // that takes a long time to handle PHASE_THIRD_PARTY_APPS_CAN_START, but that shouldn't
          // happen.)
          boolean timeoutNeeded = true;
          if ((mAm.mBootPhase < SystemService.PHASE_THIRD_PARTY_APPS_CAN_START)
                  && (r.app != null) && (r.app.pid == android.os.Process.myPid())) {
  
              Slog.w(TAG, "Too early to start/bind service in system_server: Phase=" + mAm.mBootPhase
                      + " " + r.getComponentName());
              timeoutNeeded = false;
          }
  
          long now = SystemClock.uptimeMillis();
          if (r.executeNesting == 0) {
              r.executeFg = fg;
              ServiceState stracker = r.getTracker();
              if (stracker != null) {
                  stracker.setExecuting(true, mAm.mProcessStats.getMemFactorLocked(), now);
              }
              if (r.app != null) {
                  r.app.executingServices.add(r);
                  r.app.execServicesFg |= fg;
                  if (timeoutNeeded && r.app.executingServices.size() == 1) {
                      scheduleServiceTimeoutLocked(r.app);
                  }
              }
          } else if (r.app != null && fg && !r.app.execServicesFg) {
              r.app.execServicesFg = true;
              if (timeoutNeeded) {
                  scheduleServiceTimeoutLocked(r.app);
              }
          }
          r.executeFg |= fg;
          r.executeNesting++;
          r.executingStart = now;
      }
  
      private final boolean requestServiceBindingLocked(ServiceRecord r, IntentBindRecord i,
              boolean execInFg, boolean rebind) throws TransactionTooLargeException {
          if (r.app == null || r.app.thread == null) {
              // If service is not currently running, can't yet bind.
              return false;
          }
          if (DEBUG_SERVICE) Slog.d(TAG_SERVICE, "requestBind " + i + ": requested=" + i.requested
                  + " rebind=" + rebind);
          if ((!i.requested || rebind) && i.apps.size() > 0) {
              try {
                  bumpServiceExecutingLocked(r, execInFg, "bind");
                  r.app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_SERVICE);
                  r.app.thread.scheduleBindService(r, i.intent.getIntent(), rebind,
                          r.app.getReportedProcState());
                  if (!rebind) {
                      i.requested = true;
                  }
                  i.hasBound = true;
                  i.doRebind = false;
              } catch (TransactionTooLargeException e) {
                  // Keep the executeNesting count accurate.
                  if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Crashed while binding " + r, e);
                  final boolean inDestroying = mDestroyingServices.contains(r);
                  serviceDoneExecutingLocked(r, inDestroying, inDestroying);
                  throw e;
              } catch (RemoteException e) {
                  if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Crashed while binding " + r);
                  // Keep the executeNesting count accurate.
                  final boolean inDestroying = mDestroyingServices.contains(r);
                  serviceDoneExecutingLocked(r, inDestroying, inDestroying);
                  return false;
              }
          }
          return true;
      }
  
      private final boolean scheduleServiceRestartLocked(ServiceRecord r, boolean allowCancel) {
          boolean canceled = false;
  
          if (mAm.mAtmInternal.isShuttingDown()) {
              Slog.w(TAG, "Not scheduling restart of crashed service " + r.shortInstanceName
                      + " - system is shutting down");
              return false;
          }
  
          ServiceMap smap = getServiceMapLocked(r.userId);
          if (smap.mServicesByInstanceName.get(r.instanceName) != r) {
              ServiceRecord cur = smap.mServicesByInstanceName.get(r.instanceName);
              Slog.wtf(TAG, "Attempting to schedule restart of " + r
                      + " when found in map: " + cur);
              return false;
          }
  
          final long now = SystemClock.uptimeMillis();
  
          if ((r.serviceInfo.applicationInfo.flags
                  &ApplicationInfo.FLAG_PERSISTENT) == 0) {
              long minDuration = mAm.mConstants.SERVICE_RESTART_DURATION;
              long resetTime = mAm.mConstants.SERVICE_RESET_RUN_DURATION;
  
              // Any delivered but not yet finished starts should be put back
              // on the pending list.
              final int N = r.deliveredStarts.size();
              if (N > 0) {
                  for (int i=N-1; i>=0; i--) {
                      ServiceRecord.StartItem si = r.deliveredStarts.get(i);
                      si.removeUriPermissionsLocked();
                      if (si.intent == null) {
                          // We'll generate this again if needed.
                      } else if (!allowCancel || (si.deliveryCount < ServiceRecord.MAX_DELIVERY_COUNT
                              && si.doneExecutingCount < ServiceRecord.MAX_DONE_EXECUTING_COUNT)) {
                          r.pendingStarts.add(0, si);
                          long dur = SystemClock.uptimeMillis() - si.deliveredTime;
                          dur *= 2;
                          if (minDuration < dur) minDuration = dur;
                          if (resetTime < dur) resetTime = dur;
                      } else {
                          Slog.w(TAG, "Canceling start item " + si.intent + " in service "
                                  + r.shortInstanceName);
                          canceled = true;
                      }
                  }
                  r.deliveredStarts.clear();
              }
  
              r.totalRestartCount++;
              if (r.restartDelay == 0) {
                  r.restartCount++;
                  r.restartDelay = minDuration;
              } else if (r.crashCount > 1) {
                  r.restartDelay = mAm.mConstants.BOUND_SERVICE_CRASH_RESTART_DURATION
                          * (r.crashCount - 1);
              } else {
                  // If it has been a "reasonably long time" since the service
                  // was started, then reset our restart duration back to
                  // the beginning, so we don't infinitely increase the duration
                  // on a service that just occasionally gets killed (which is
                  // a normal case, due to process being killed to reclaim memory).
                  if (now > (r.restartTime+resetTime)) {
                      r.restartCount = 1;
                      r.restartDelay = minDuration;
                  } else {
                      r.restartDelay *= mAm.mConstants.SERVICE_RESTART_DURATION_FACTOR;
                      if (r.restartDelay < minDuration) {
                          r.restartDelay = minDuration;
                      }
                  }
              }
  
              r.nextRestartTime = now + r.restartDelay;
  
              // Make sure that we don't end up restarting a bunch of services
              // all at the same time.
              boolean repeat;
              do {
                  repeat = false;
                  final long restartTimeBetween = mAm.mConstants.SERVICE_MIN_RESTART_TIME_BETWEEN;
                  for (int i=mRestartingServices.size()-1; i>=0; i--) {
                      ServiceRecord r2 = mRestartingServices.get(i);
                      if (r2 != r && r.nextRestartTime >= (r2.nextRestartTime-restartTimeBetween)
                              && r.nextRestartTime < (r2.nextRestartTime+restartTimeBetween)) {
                          r.nextRestartTime = r2.nextRestartTime + restartTimeBetween;
                          r.restartDelay = r.nextRestartTime - now;
                          repeat = true;
                          break;
                      }
                  }
              } while (repeat);
  
          } else {
              // Persistent processes are immediately restarted, so there is no
              // reason to hold of on restarting their services.
              r.totalRestartCount++;
              r.restartCount = 0;
              r.restartDelay = 0;
              r.nextRestartTime = now;
          }
  
          if (!mRestartingServices.contains(r)) {
              r.createdFromFg = false;
              mRestartingServices.add(r);
              r.makeRestarting(mAm.mProcessStats.getMemFactorLocked(), now);
          }
  
          cancelForegroundNotificationLocked(r);
  
          mAm.mHandler.removeCallbacks(r.restarter);
          mAm.mHandler.postAtTime(r.restarter, r.nextRestartTime);
          r.nextRestartTime = SystemClock.uptimeMillis() + r.restartDelay;
          Slog.w(TAG, "Scheduling restart of crashed service "
                  + r.shortInstanceName + " in " + r.restartDelay + "ms");
          EventLog.writeEvent(EventLogTags.AM_SCHEDULE_SERVICE_RESTART,
                  r.userId, r.shortInstanceName, r.restartDelay);
  
          return canceled;
      }
  
      final void performServiceRestartLocked(ServiceRecord r) {
          if (!mRestartingServices.contains(r)) {
              return;
          }
          if (!isServiceNeededLocked(r, false, false)) {
              // Paranoia: is this service actually needed?  In theory a service that is not
              // needed should never remain on the restart list.  In practice...  well, there
              // have been bugs where this happens, and bad things happen because the process
              // ends up just being cached, so quickly killed, then restarted again and again.
              // Let's not let that happen.
              Slog.wtf(TAG, "Restarting service that is not needed: " + r);
              return;
          }
          try {
              bringUpServiceLocked(r, r.intent.getIntent().getFlags(), r.createdFromFg, true, false);
          } catch (TransactionTooLargeException e) {
              // Ignore, it's been logged and nothing upstack cares.
          }
      }
  
      private final boolean unscheduleServiceRestartLocked(ServiceRecord r, int callingUid,
              boolean force) {
          if (!force && r.restartDelay == 0) {
              return false;
          }
          // Remove from the restarting list; if the service is currently on the
          // restarting list, or the call is coming from another app, then this
          // service has become of much more interest so we reset the restart interval.
          boolean removed = mRestartingServices.remove(r);
          if (removed || callingUid != r.appInfo.uid) {
              r.resetRestartCounter();
          }
          if (removed) {
              clearRestartingIfNeededLocked(r);
          }
          mAm.mHandler.removeCallbacks(r.restarter);
          return true;
      }
  
      private void clearRestartingIfNeededLocked(ServiceRecord r) {
          if (r.restartTracker != null) {
              // If this is the last restarting record with this tracker, then clear
              // the tracker's restarting state.
              boolean stillTracking = false;
              for (int i=mRestartingServices.size()-1; i>=0; i--) {
                  if (mRestartingServices.get(i).restartTracker == r.restartTracker) {
                      stillTracking = true;
                      break;
                  }
              }
              if (!stillTracking) {
                  r.restartTracker.setRestarting(false, mAm.mProcessStats.getMemFactorLocked(),
                          SystemClock.uptimeMillis());
                  r.restartTracker = null;
              }
          }
      }
  
      private String bringUpServiceLocked(ServiceRecord r, int intentFlags, boolean execInFg,
              boolean whileRestarting, boolean permissionsReviewRequired)
              throws TransactionTooLargeException {
          if (r.app != null && r.app.thread != null) {
              sendServiceArgsLocked(r, execInFg, false);
              return null;
          }
  
          if (!whileRestarting && mRestartingServices.contains(r)) {
              // If waiting for a restart, then do nothing.
              return null;
          }
  
          if (DEBUG_SERVICE) {
              Slog.v(TAG_SERVICE, "Bringing up " + r + " " + r.intent + " fg=" + r.fgRequired);
          }
  
          // We are now bringing the service up, so no longer in the
          // restarting state.
          if (mRestartingServices.remove(r)) {
              clearRestartingIfNeededLocked(r);
          }
  
          // Make sure this service is no longer considered delayed, we are starting it now.
          if (r.delayed) {
              if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE, "REM FR DELAY LIST (bring up): " + r);
              getServiceMapLocked(r.userId).mDelayedStartList.remove(r);
              r.delayed = false;
          }
  
          // Make sure that the user who owns this service is started.  If not,
          // we don't want to allow it to run.
          if (!mAm.mUserController.hasStartedUserState(r.userId)) {
              String msg = "Unable to launch app "
                      + r.appInfo.packageName + "/"
                      + r.appInfo.uid + " for service "
                      + r.intent.getIntent() + ": user " + r.userId + " is stopped";
              Slog.w(TAG, msg);
              bringDownServiceLocked(r);
              return msg;
          }
  
          // Service is now being launched, its package can't be stopped.
          try {
              AppGlobals.getPackageManager().setPackageStoppedState(
                      r.packageName, false, r.userId);
          } catch (RemoteException e) {
          } catch (IllegalArgumentException e) {
              Slog.w(TAG, "Failed trying to unstop package "
                      + r.packageName + ": " + e);
          }
  
          final boolean isolated = (r.serviceInfo.flags&ServiceInfo.FLAG_ISOLATED_PROCESS) != 0;
          final String procName = r.processName;
          HostingRecord hostingRecord = new HostingRecord("service", r.instanceName);
          ProcessRecord app;
  
          if (!isolated) {
              app = mAm.getProcessRecordLocked(procName, r.appInfo.uid, false);
              if (DEBUG_MU) Slog.v(TAG_MU, "bringUpServiceLocked: appInfo.uid=" + r.appInfo.uid
                          + " app=" + app);
              if (app != null && app.thread != null) {
                  try {
                      app.addPackage(r.appInfo.packageName, r.appInfo.longVersionCode, mAm.mProcessStats);
                      realStartServiceLocked(r, app, execInFg);
                      return null;
                  } catch (TransactionTooLargeException e) {
                      throw e;
                  } catch (RemoteException e) {
                      Slog.w(TAG, "Exception when starting service " + r.shortInstanceName, e);
                  }
  
                  // If a dead object exception was thrown -- fall through to
                  // restart the application.
              }
          } else {
              // If this service runs in an isolated process, then each time
              // we call startProcessLocked() we will get a new isolated
              // process, starting another process if we are currently waiting
              // for a previous process to come up.  To deal with this, we store
              // in the service any current isolated process it is running in or
              // waiting to have come up.
              app = r.isolatedProc;
              if (WebViewZygote.isMultiprocessEnabled()
                      && r.serviceInfo.packageName.equals(WebViewZygote.getPackageName())) {
                  hostingRecord = HostingRecord.byWebviewZygote(r.instanceName);
              }
              if ((r.serviceInfo.flags & ServiceInfo.FLAG_USE_APP_ZYGOTE) != 0) {
                  hostingRecord = HostingRecord.byAppZygote(r.instanceName, r.definingPackageName,
                          r.definingUid);
              }
          }
  
          // Not running -- get it started, and enqueue this service record
          // to be executed when the app comes up.
          if (app == null && !permissionsReviewRequired) {
              if ((app=mAm.startProcessLocked(procName, r.appInfo, true, intentFlags,
                      hostingRecord, false, isolated, false)) == null) {
                  String msg = "Unable to launch app "
                          + r.appInfo.packageName + "/"
                          + r.appInfo.uid + " for service "
                          + r.intent.getIntent() + ": process is bad";
                  Slog.w(TAG, msg);
                  bringDownServiceLocked(r);
                  return msg;
              }
              if (isolated) {
                  r.isolatedProc = app;
              }
          }
  
          if (r.fgRequired) {
              if (DEBUG_FOREGROUND_SERVICE) {
                  Slog.v(TAG, "Whitelisting " + UserHandle.formatUid(r.appInfo.uid)
                          + " for fg-service launch");
              }
              mAm.tempWhitelistUidLocked(r.appInfo.uid,
                      SERVICE_START_FOREGROUND_TIMEOUT, "fg-service-launch");
          }
  
          if (!mPendingServices.contains(r)) {
              mPendingServices.add(r);
          }
  
          if (r.delayedStop) {
              // Oh and hey we've already been asked to stop!
              r.delayedStop = false;
              if (r.startRequested) {
                  if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE,
                          "Applying delayed stop (in bring up): " + r);
                  stopServiceLocked(r);
              }
          }
  
          return null;
      }
  
      private final void requestServiceBindingsLocked(ServiceRecord r, boolean execInFg)
              throws TransactionTooLargeException {
          for (int i=r.bindings.size()-1; i>=0; i--) {
              IntentBindRecord ibr = r.bindings.valueAt(i);
              if (!requestServiceBindingLocked(r, ibr, execInFg, false)) {
                  break;
              }
          }
      }
  
      /**
       * Note the name of this method should not be confused with the started services concept.
       * The "start" here means bring up the instance in the client, and this method is called
       * from bindService() as well.
       */
      private final void realStartServiceLocked(ServiceRecord r,
              ProcessRecord app, boolean execInFg) throws RemoteException {
          if (app.thread == null) {
              throw new RemoteException();
          }
          if (DEBUG_MU)
              Slog.v(TAG_MU, "realStartServiceLocked, ServiceRecord.uid = " + r.appInfo.uid
                      + ", ProcessRecord.uid = " + app.uid);
          r.setProcess(app);
          r.restartTime = r.lastActivity = SystemClock.uptimeMillis();
  
          final boolean newService = app.services.add(r);
          bumpServiceExecutingLocked(r, execInFg, "create");
          mAm.updateLruProcessLocked(app, false, null);
          updateServiceForegroundLocked(r.app, /* oomAdj= */ false);
          mAm.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_START_SERVICE);
  
          boolean created = false;
          try {
              if (LOG_SERVICE_START_STOP) {
                  String nameTerm;
                  int lastPeriod = r.shortInstanceName.lastIndexOf('.');
                  nameTerm = lastPeriod >= 0 ? r.shortInstanceName.substring(lastPeriod)
                          : r.shortInstanceName;
                  EventLogTags.writeAmCreateService(
                          r.userId, System.identityHashCode(r), nameTerm, r.app.uid, r.app.pid);
              }
              StatsLog.write(StatsLog.SERVICE_LAUNCH_REPORTED, r.appInfo.uid, r.name.getPackageName(),
                      r.name.getClassName());
              synchronized (r.stats.getBatteryStats()) {
                  r.stats.startLaunchedLocked();
              }
              mAm.notifyPackageUse(r.serviceInfo.packageName,
                                   PackageManager.NOTIFY_PACKAGE_USE_SERVICE);
              app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_SERVICE);
              app.thread.scheduleCreateService(r, r.serviceInfo,
                      mAm.compatibilityInfoForPackage(r.serviceInfo.applicationInfo),
                      app.getReportedProcState());
              r.postNotification();
              created = true;
          } catch (DeadObjectException e) {
              Slog.w(TAG, "Application dead when creating service " + r);
              mAm.appDiedLocked(app);
              throw e;
          } finally {
              if (!created) {
                  // Keep the executeNesting count accurate.
                  final boolean inDestroying = mDestroyingServices.contains(r);
                  serviceDoneExecutingLocked(r, inDestroying, inDestroying);
  
                  // Cleanup.
                  if (newService) {
                      app.services.remove(r);
                      r.setProcess(null);
                  }
  
                  // Retry.
                  if (!inDestroying) {
                      scheduleServiceRestartLocked(r, false);
                  }
              }
          }
  
          if (r.whitelistManager) {
              app.whitelistManager = true;
          }
  
          requestServiceBindingsLocked(r, execInFg);
  
          updateServiceClientActivitiesLocked(app, null, true);
  
          if (newService && created) {
              app.addBoundClientUidsOfNewService(r);
          }
  
          // If the service is in the started state, and there are no
          // pending arguments, then fake up one so its onStartCommand() will
          // be called.
          if (r.startRequested && r.callStart && r.pendingStarts.size() == 0) {
              r.pendingStarts.add(new ServiceRecord.StartItem(r, false, r.makeNextStartId(),
                      null, null, 0));
          }
  
          sendServiceArgsLocked(r, execInFg, true);
  
          if (r.delayed) {
              if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE, "REM FR DELAY LIST (new proc): " + r);
              getServiceMapLocked(r.userId).mDelayedStartList.remove(r);
              r.delayed = false;
          }
  
          if (r.delayedStop) {
              // Oh and hey we've already been asked to stop!
              r.delayedStop = false;
              if (r.startRequested) {
                  if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE,
                          "Applying delayed stop (from start): " + r);
                  stopServiceLocked(r);
              }
          }
      }
  
      private final void sendServiceArgsLocked(ServiceRecord r, boolean execInFg,
              boolean oomAdjusted) throws TransactionTooLargeException {
          final int N = r.pendingStarts.size();
          if (N == 0) {
              return;
          }
  
          ArrayList<ServiceStartArgs> args = new ArrayList<>();
  
          while (r.pendingStarts.size() > 0) {
              ServiceRecord.StartItem si = r.pendingStarts.remove(0);
              if (DEBUG_SERVICE) {
                  Slog.v(TAG_SERVICE, "Sending arguments to: "
                          + r + " " + r.intent + " args=" + si.intent);
              }
              if (si.intent == null && N > 1) {
                  // If somehow we got a dummy null intent in the middle,
                  // then skip it.  DO NOT skip a null intent when it is
                  // the only one in the list -- this is to support the
                  // onStartCommand(null) case.
                  continue;
              }
              si.deliveredTime = SystemClock.uptimeMillis();
              r.deliveredStarts.add(si);
              si.deliveryCount++;
              if (si.neededGrants != null) {
                  mAm.mUgmInternal.grantUriPermissionUncheckedFromIntent(si.neededGrants,
                          si.getUriPermissionsLocked());
              }
              mAm.grantEphemeralAccessLocked(r.userId, si.intent, UserHandle.getAppId(r.appInfo.uid),
                      UserHandle.getAppId(si.callingId));
              bumpServiceExecutingLocked(r, execInFg, "start");
              if (!oomAdjusted) {
                  oomAdjusted = true;
                  mAm.updateOomAdjLocked(r.app, true, OomAdjuster.OOM_ADJ_REASON_START_SERVICE);
              }
              if (r.fgRequired && !r.fgWaiting) {
                  if (!r.isForeground) {
                      if (DEBUG_BACKGROUND_CHECK) {
                          Slog.i(TAG, "Launched service must call startForeground() within timeout: " + r);
                      }
                      scheduleServiceForegroundTransitionTimeoutLocked(r);
                  } else {
                      if (DEBUG_BACKGROUND_CHECK) {
                          Slog.i(TAG, "Service already foreground; no new timeout: " + r);
                      }
                      r.fgRequired = false;
                  }
              }
              int flags = 0;
              if (si.deliveryCount > 1) {
                  flags |= Service.START_FLAG_RETRY;
              }
              if (si.doneExecutingCount > 0) {
                  flags |= Service.START_FLAG_REDELIVERY;
              }
              args.add(new ServiceStartArgs(si.taskRemoved, si.id, flags, si.intent));
          }
  
          ParceledListSlice<ServiceStartArgs> slice = new ParceledListSlice<>(args);
          slice.setInlineCountLimit(4);
          Exception caughtException = null;
          try {
              r.app.thread.scheduleServiceArgs(r, slice);
          } catch (TransactionTooLargeException e) {
              if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Transaction too large for " + args.size()
                      + " args, first: " + args.get(0).args);
              Slog.w(TAG, "Failed delivering service starts", e);
              caughtException = e;
          } catch (RemoteException e) {
              // Remote process gone...  we'll let the normal cleanup take care of this.
              if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Crashed while sending args: " + r);
              Slog.w(TAG, "Failed delivering service starts", e);
              caughtException = e;
          } catch (Exception e) {
              Slog.w(TAG, "Unexpected exception", e);
              caughtException = e;
          }
  
          if (caughtException != null) {
              // Keep nesting count correct
              final boolean inDestroying = mDestroyingServices.contains(r);
              for (int i = 0; i < args.size(); i++) {
                  serviceDoneExecutingLocked(r, inDestroying, inDestroying);
              }
              if (caughtException instanceof TransactionTooLargeException) {
                  throw (TransactionTooLargeException)caughtException;
              }
          }
      }
  
      private final boolean isServiceNeededLocked(ServiceRecord r, boolean knowConn,
              boolean hasConn) {
          // Are we still explicitly being asked to run?
          if (r.startRequested) {
              return true;
          }
  
          // Is someone still bound to us keeping us running?
          if (!knowConn) {
              hasConn = r.hasAutoCreateConnections();
          }
          if (hasConn) {
              return true;
          }
  
          return false;
      }
  
      private final void bringDownServiceIfNeededLocked(ServiceRecord r, boolean knowConn,
              boolean hasConn) {
          //Slog.i(TAG, "Bring down service:");
          //r.dump("  ");
  
          if (isServiceNeededLocked(r, knowConn, hasConn)) {
              return;
          }
  
          // Are we in the process of launching?
          if (mPendingServices.contains(r)) {
              return;
          }
  
          bringDownServiceLocked(r);
      }
  
      private final void bringDownServiceLocked(ServiceRecord r) {
          //Slog.i(TAG, "Bring down service:");
          //r.dump("  ");
  
          // Report to all of the connections that the service is no longer
          // available.
          ArrayMap<IBinder, ArrayList<ConnectionRecord>> connections = r.getConnections();
          for (int conni = connections.size() - 1; conni >= 0; conni--) {
              ArrayList<ConnectionRecord> c = connections.valueAt(conni);
              for (int i=0; i<c.size(); i++) {
                  ConnectionRecord cr = c.get(i);
                  // There is still a connection to the service that is
                  // being brought down.  Mark it as dead.
                  cr.serviceDead = true;
                  cr.stopAssociation();
                  try {
                      cr.conn.connected(r.name, null, true);
                  } catch (Exception e) {
                      Slog.w(TAG, "Failure disconnecting service " + r.shortInstanceName
                            + " to connection " + c.get(i).conn.asBinder()
                            + " (in " + c.get(i).binding.client.processName + ")", e);
                  }
              }
          }
  
          // Tell the service that it has been unbound.
          if (r.app != null && r.app.thread != null) {
              boolean needOomAdj = false;
              for (int i = r.bindings.size() - 1; i >= 0; i--) {
                  IntentBindRecord ibr = r.bindings.valueAt(i);
                  if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Bringing down binding " + ibr
                          + ": hasBound=" + ibr.hasBound);
                  if (ibr.hasBound) {
                      try {
                          bumpServiceExecutingLocked(r, false, "bring down unbind");
                          needOomAdj = true;
                          ibr.hasBound = false;
                          ibr.requested = false;
                          r.app.thread.scheduleUnbindService(r,
                                  ibr.intent.getIntent());
                      } catch (Exception e) {
                          Slog.w(TAG, "Exception when unbinding service "
                                  + r.shortInstanceName, e);
                          serviceProcessGoneLocked(r);
                      }
                  }
              }
              if (needOomAdj) {
                  mAm.updateOomAdjLocked(r.app, true,
                          OomAdjuster.OOM_ADJ_REASON_UNBIND_SERVICE);
              }
          }
  
          // Check to see if the service had been started as foreground, but being
          // brought down before actually showing a notification.  That is not allowed.
          if (r.fgRequired) {
              Slog.w(TAG_SERVICE, "Bringing down service while still waiting for start foreground: "
                      + r);
              r.fgRequired = false;
              r.fgWaiting = false;
              ServiceState stracker = r.getTracker();
              if (stracker != null) {
                  stracker.setForeground(false, mAm.mProcessStats.getMemFactorLocked(),
                          r.lastActivity);
              }
              mAm.mAppOpsService.finishOperation(AppOpsManager.getToken(mAm.mAppOpsService),
                      AppOpsManager.OP_START_FOREGROUND, r.appInfo.uid, r.packageName);
              mAm.mHandler.removeMessages(
                      ActivityManagerService.SERVICE_FOREGROUND_TIMEOUT_MSG, r);
              if (r.app != null) {
                  Message msg = mAm.mHandler.obtainMessage(
                          ActivityManagerService.SERVICE_FOREGROUND_CRASH_MSG);
                  msg.obj = r.app;
                  msg.getData().putCharSequence(
                      ActivityManagerService.SERVICE_RECORD_KEY, r.toString());
                  mAm.mHandler.sendMessage(msg);
              }
          }
  
          if (DEBUG_SERVICE) {
              RuntimeException here = new RuntimeException();
              here.fillInStackTrace();
              Slog.v(TAG_SERVICE, "Bringing down " + r + " " + r.intent, here);
          }
          r.destroyTime = SystemClock.uptimeMillis();
          if (LOG_SERVICE_START_STOP) {
              EventLogTags.writeAmDestroyService(
                      r.userId, System.identityHashCode(r), (r.app != null) ? r.app.pid : -1);
          }
  
          final ServiceMap smap = getServiceMapLocked(r.userId);
          ServiceRecord found = smap.mServicesByInstanceName.remove(r.instanceName);
  
          // Note when this method is called by bringUpServiceLocked(), the service is not found
          // in mServicesByInstanceName and found will be null.
          if (found != null && found != r) {
              // This is not actually the service we think is running...  this should not happen,
              // but if it does, fail hard.
              smap.mServicesByInstanceName.put(r.instanceName, found);
              throw new IllegalStateException("Bringing down " + r + " but actually running "
                      + found);
          }
          smap.mServicesByIntent.remove(r.intent);
          r.totalRestartCount = 0;
          unscheduleServiceRestartLocked(r, 0, true);
  
          // Also make sure it is not on the pending list.
          for (int i=mPendingServices.size()-1; i>=0; i--) {
              if (mPendingServices.get(i) == r) {
                  mPendingServices.remove(i);
                  if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Removed pending: " + r);
              }
          }
  
          cancelForegroundNotificationLocked(r);
          if (r.isForeground) {
              decActiveForegroundAppLocked(smap, r);
              ServiceState stracker = r.getTracker();
              if (stracker != null) {
                  stracker.setForeground(false, mAm.mProcessStats.getMemFactorLocked(),
                          r.lastActivity);
              }
              mAm.mAppOpsService.finishOperation(
                      AppOpsManager.getToken(mAm.mAppOpsService),
                      AppOpsManager.OP_START_FOREGROUND, r.appInfo.uid, r.packageName);
              StatsLog.write(StatsLog.FOREGROUND_SERVICE_STATE_CHANGED, r.appInfo.uid,
                      r.shortInstanceName, StatsLog.FOREGROUND_SERVICE_STATE_CHANGED__STATE__EXIT);
              mAm.updateForegroundServiceUsageStats(r.name, r.userId, false);
          }
  
          r.isForeground = false;
          r.foregroundId = 0;
          r.foregroundNoti = null;
  
          // Clear start entries.
          r.clearDeliveredStartsLocked();
          r.pendingStarts.clear();
          smap.mDelayedStartList.remove(r);
  
          if (r.app != null) {
              synchronized (r.stats.getBatteryStats()) {
                  r.stats.stopLaunchedLocked();
              }
              r.app.services.remove(r);
              r.app.updateBoundClientUids();
              if (r.whitelistManager) {
                  updateWhitelistManagerLocked(r.app);
              }
              if (r.app.thread != null) {
                  updateServiceForegroundLocked(r.app, false);
                  try {
                      bumpServiceExecutingLocked(r, false, "destroy");
                      mDestroyingServices.add(r);
                      r.destroying = true;
                      mAm.updateOomAdjLocked(r.app, true,
                              OomAdjuster.OOM_ADJ_REASON_UNBIND_SERVICE);
                      r.app.thread.scheduleStopService(r);
                  } catch (Exception e) {
                      Slog.w(TAG, "Exception when destroying service "
                              + r.shortInstanceName, e);
                      serviceProcessGoneLocked(r);
                  }
              } else {
                  if (DEBUG_SERVICE) Slog.v(
                      TAG_SERVICE, "Removed service that has no process: " + r);
              }
          } else {
              if (DEBUG_SERVICE) Slog.v(
                  TAG_SERVICE, "Removed service that is not running: " + r);
          }
  
          if (r.bindings.size() > 0) {
              r.bindings.clear();
          }
  
          if (r.restarter instanceof ServiceRestarter) {
             ((ServiceRestarter)r.restarter).setService(null);
          }
  
          int memFactor = mAm.mProcessStats.getMemFactorLocked();
          long now = SystemClock.uptimeMillis();
          if (r.tracker != null) {
              r.tracker.setStarted(false, memFactor, now);
              r.tracker.setBound(false, memFactor, now);
              if (r.executeNesting == 0) {
                  r.tracker.clearCurrentOwner(r, false);
                  r.tracker = null;
              }
          }
  
          smap.ensureNotStartingBackgroundLocked(r);
      }
  
      void removeConnectionLocked(ConnectionRecord c, ProcessRecord skipApp,
              ActivityServiceConnectionsHolder skipAct) {
          IBinder binder = c.conn.asBinder();
          AppBindRecord b = c.binding;
          ServiceRecord s = b.service;
          ArrayList<ConnectionRecord> clist = s.getConnections().get(binder);
          if (clist != null) {
              clist.remove(c);
              if (clist.size() == 0) {
                  s.removeConnection(binder);
              }
          }
          b.connections.remove(c);
          c.stopAssociation();
          if (c.activity != null && c.activity != skipAct) {
              c.activity.removeConnection(c);
          }
          if (b.client != skipApp) {
              b.client.connections.remove(c);
              if ((c.flags&Context.BIND_ABOVE_CLIENT) != 0) {
                  b.client.updateHasAboveClientLocked();
              }
              // If this connection requested whitelist management, see if we should
              // now clear that state.
              if ((c.flags&Context.BIND_ALLOW_WHITELIST_MANAGEMENT) != 0) {
                  s.updateWhitelistManager();
                  if (!s.whitelistManager && s.app != null) {
                      updateWhitelistManagerLocked(s.app);
                  }
              }
              // And do the same for bg activity starts whitelisting.
              if ((c.flags & Context.BIND_ALLOW_BACKGROUND_ACTIVITY_STARTS) != 0) {
                  s.updateHasBindingWhitelistingBgActivityStarts();
              }
              if (s.app != null) {
                  updateServiceClientActivitiesLocked(s.app, c, true);
              }
          }
          clist = mServiceConnections.get(binder);
          if (clist != null) {
              clist.remove(c);
              if (clist.size() == 0) {
                  mServiceConnections.remove(binder);
              }
          }
  
          mAm.stopAssociationLocked(b.client.uid, b.client.processName, s.appInfo.uid,
                  s.appInfo.longVersionCode, s.instanceName, s.processName);
  
          if (b.connections.size() == 0) {
              b.intent.apps.remove(b.client);
          }
  
          if (!c.serviceDead) {
              if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Disconnecting binding " + b.intent
                      + ": shouldUnbind=" + b.intent.hasBound);
              if (s.app != null && s.app.thread != null && b.intent.apps.size() == 0
                      && b.intent.hasBound) {
                  try {
                      bumpServiceExecutingLocked(s, false, "unbind");
                      if (b.client != s.app && (c.flags&Context.BIND_WAIVE_PRIORITY) == 0
                              && s.app.setProcState <= ActivityManager.PROCESS_STATE_HEAVY_WEIGHT) {
                          // If this service's process is not already in the cached list,
                          // then update it in the LRU list here because this may be causing
                          // it to go down there and we want it to start out near the top.
                          mAm.updateLruProcessLocked(s.app, false, null);
                      }
                      mAm.updateOomAdjLocked(s.app, true,
                              OomAdjuster.OOM_ADJ_REASON_UNBIND_SERVICE);
                      b.intent.hasBound = false;
                      // Assume the client doesn't want to know about a rebind;
                      // we will deal with that later if it asks for one.
                      b.intent.doRebind = false;
                      s.app.thread.scheduleUnbindService(s, b.intent.intent.getIntent());
                  } catch (Exception e) {
                      Slog.w(TAG, "Exception when unbinding service " + s.shortInstanceName, e);
                      serviceProcessGoneLocked(s);
                  }
              }
  
              // If unbound while waiting to start and there is no connection left in this service,
              // remove the pending service
              if (s.getConnections().isEmpty()) {
                  mPendingServices.remove(s);
              }
  
              if ((c.flags&Context.BIND_AUTO_CREATE) != 0) {
                  boolean hasAutoCreate = s.hasAutoCreateConnections();
                  if (!hasAutoCreate) {
                      if (s.tracker != null) {
                          s.tracker.setBound(false, mAm.mProcessStats.getMemFactorLocked(),
                                  SystemClock.uptimeMillis());
                      }
                  }
                  bringDownServiceIfNeededLocked(s, true, hasAutoCreate);
              }
          }
      }
  
      void serviceDoneExecutingLocked(ServiceRecord r, int type, int startId, int res) {
          boolean inDestroying = mDestroyingServices.contains(r);
          if (r != null) {
              if (type == ActivityThread.SERVICE_DONE_EXECUTING_START) {
                  // This is a call from a service start...  take care of
                  // book-keeping.
                  r.callStart = true;
                  switch (res) {
                      case Service.START_STICKY_COMPATIBILITY:
                      case Service.START_STICKY: {
                          // We are done with the associated start arguments.
                          r.findDeliveredStart(startId, false, true);
                          // Don't stop if killed.
                          r.stopIfKilled = false;
                          break;
                      }
                      case Service.START_NOT_STICKY: {
                          // We are done with the associated start arguments.
                          r.findDeliveredStart(startId, false, true);
                          if (r.getLastStartId() == startId) {
                              // There is no more work, and this service
                              // doesn't want to hang around if killed.
                              r.stopIfKilled = true;
                          }
                          break;
                      }
                      case Service.START_REDELIVER_INTENT: {
                          // We'll keep this item until they explicitly
                          // call stop for it, but keep track of the fact
                          // that it was delivered.
                          ServiceRecord.StartItem si = r.findDeliveredStart(startId, false, false);
                          if (si != null) {
                              si.deliveryCount = 0;
                              si.doneExecutingCount++;
                              // Don't stop if killed.
                              r.stopIfKilled = true;
                          }
                          break;
                      }
                      case Service.START_TASK_REMOVED_COMPLETE: {
                          // Special processing for onTaskRemoved().  Don't
                          // impact normal onStartCommand() processing.
                          r.findDeliveredStart(startId, true, true);
                          break;
                      }
                      default:
                          throw new IllegalArgumentException(
                                  "Unknown service start result: " + res);
                  }
                  if (res == Service.START_STICKY_COMPATIBILITY) {
                      r.callStart = false;
                  }
              } else if (type == ActivityThread.SERVICE_DONE_EXECUTING_STOP) {
                  // This is the final call from destroying the service...  we should
                  // actually be getting rid of the service at this point.  Do some
                  // validation of its state, and ensure it will be fully removed.
                  if (!inDestroying) {
                      // Not sure what else to do with this...  if it is not actually in the
                      // destroying list, we don't need to make sure to remove it from it.
                      // If the app is null, then it was probably removed because the process died,
                      // otherwise wtf
                      if (r.app != null) {
                          Slog.w(TAG, "Service done with onDestroy, but not inDestroying: "
                                  + r + ", app=" + r.app);
                      }
                  } else if (r.executeNesting != 1) {
                      Slog.w(TAG, "Service done with onDestroy, but executeNesting="
                              + r.executeNesting + ": " + r);
                      // Fake it to keep from ANR due to orphaned entry.
                      r.executeNesting = 1;
                  }
              }
              final long origId = Binder.clearCallingIdentity();
              serviceDoneExecutingLocked(r, inDestroying, inDestroying);
              Binder.restoreCallingIdentity(origId);
          } else {
              Slog.w(TAG, "Done executing unknown service from pid "
                      + Binder.getCallingPid());
          }
      }
  
      private void serviceProcessGoneLocked(ServiceRecord r) {
          if (r.tracker != null) {
              int memFactor = mAm.mProcessStats.getMemFactorLocked();
              long now = SystemClock.uptimeMillis();
              r.tracker.setExecuting(false, memFactor, now);
              r.tracker.setForeground(false, memFactor, now);
              r.tracker.setBound(false, memFactor, now);
              r.tracker.setStarted(false, memFactor, now);
          }
          serviceDoneExecutingLocked(r, true, true);
      }
  
      private void serviceDoneExecutingLocked(ServiceRecord r, boolean inDestroying,
              boolean finishing) {
          if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "<<< DONE EXECUTING " + r
                  + ": nesting=" + r.executeNesting
                  + ", inDestroying=" + inDestroying + ", app=" + r.app);
          else if (DEBUG_SERVICE_EXECUTING) Slog.v(TAG_SERVICE_EXECUTING,
                  "<<< DONE EXECUTING " + r.shortInstanceName);
          r.executeNesting--;
          if (r.executeNesting <= 0) {
              if (r.app != null) {
                  if (DEBUG_SERVICE) Slog.v(TAG_SERVICE,
                          "Nesting at 0 of " + r.shortInstanceName);
                  r.app.execServicesFg = false;
                  r.app.executingServices.remove(r);
                  if (r.app.executingServices.size() == 0) {
                      if (DEBUG_SERVICE || DEBUG_SERVICE_EXECUTING) Slog.v(TAG_SERVICE_EXECUTING,
                              "No more executingServices of " + r.shortInstanceName);
                      mAm.mHandler.removeMessages(ActivityManagerService.SERVICE_TIMEOUT_MSG, r.app);
                  } else if (r.executeFg) {
                      // Need to re-evaluate whether the app still needs to be in the foreground.
                      for (int i=r.app.executingServices.size()-1; i>=0; i--) {
                          if (r.app.executingServices.valueAt(i).executeFg) {
                              r.app.execServicesFg = true;
                              break;
                          }
                      }
                  }
                  if (inDestroying) {
                      if (DEBUG_SERVICE) Slog.v(TAG_SERVICE,
                              "doneExecuting remove destroying " + r);
                      mDestroyingServices.remove(r);
                      r.bindings.clear();
                  }
                  mAm.updateOomAdjLocked(r.app, true, OomAdjuster.OOM_ADJ_REASON_UNBIND_SERVICE);
              }
              r.executeFg = false;
              if (r.tracker != null) {
                  final int memFactor = mAm.mProcessStats.getMemFactorLocked();
                  final long now = SystemClock.uptimeMillis();
                  r.tracker.setExecuting(false, memFactor, now);
                  r.tracker.setForeground(false, memFactor, now);
                  if (finishing) {
                      r.tracker.clearCurrentOwner(r, false);
                      r.tracker = null;
                  }
              }
              if (finishing) {
                  if (r.app != null && !r.app.isPersistent()) {
                      r.app.services.remove(r);
                      r.app.updateBoundClientUids();
                      if (r.whitelistManager) {
                          updateWhitelistManagerLocked(r.app);
                      }
                  }
                  r.setProcess(null);
              }
          }
      }
  
      boolean attachApplicationLocked(ProcessRecord proc, String processName)
              throws RemoteException {
          boolean didSomething = false;
          // Collect any services that are waiting for this process to come up.
          if (mPendingServices.size() > 0) {
              ServiceRecord sr = null;
              try {
                  for (int i=0; i<mPendingServices.size(); i++) {
                      sr = mPendingServices.get(i);
                      if (proc != sr.isolatedProc && (proc.uid != sr.appInfo.uid
                              || !processName.equals(sr.processName))) {
                          continue;
                      }
  
                      mPendingServices.remove(i);
                      i--;
                      proc.addPackage(sr.appInfo.packageName, sr.appInfo.longVersionCode,
                              mAm.mProcessStats);
                      realStartServiceLocked(sr, proc, sr.createdFromFg);
                      didSomething = true;
                      if (!isServiceNeededLocked(sr, false, false)) {
                          // We were waiting for this service to start, but it is actually no
                          // longer needed.  This could happen because bringDownServiceIfNeeded
                          // won't bring down a service that is pending...  so now the pending
                          // is done, so let's drop it.
                          bringDownServiceLocked(sr);
                      }
                  }
              } catch (RemoteException e) {
                  Slog.w(TAG, "Exception in new application when starting service "
                          + sr.shortInstanceName, e);
                  throw e;
              }
          }
          // Also, if there are any services that are waiting to restart and
          // would run in this process, now is a good time to start them.  It would
          // be weird to bring up the process but arbitrarily not let the services
          // run at this point just because their restart time hasn't come up.
          if (mRestartingServices.size() > 0) {
              ServiceRecord sr;
              for (int i=0; i<mRestartingServices.size(); i++) {
                  sr = mRestartingServices.get(i);
                  if (proc != sr.isolatedProc && (proc.uid != sr.appInfo.uid
                          || !processName.equals(sr.processName))) {
                      continue;
                  }
                  mAm.mHandler.removeCallbacks(sr.restarter);
                  mAm.mHandler.post(sr.restarter);
              }
          }
          return didSomething;
      }
  
      void processStartTimedOutLocked(ProcessRecord proc) {
          for (int i=0; i<mPendingServices.size(); i++) {
              ServiceRecord sr = mPendingServices.get(i);
              if ((proc.uid == sr.appInfo.uid
                      && proc.processName.equals(sr.processName))
                      || sr.isolatedProc == proc) {
                  Slog.w(TAG, "Forcing bringing down service: " + sr);
                  sr.isolatedProc = null;
                  mPendingServices.remove(i);
                  i--;
                  bringDownServiceLocked(sr);
              }
          }
      }
  
      private boolean collectPackageServicesLocked(String packageName, Set<String> filterByClasses,
              boolean evenPersistent, boolean doit, ArrayMap<ComponentName, ServiceRecord> services) {
          boolean didSomething = false;
          for (int i = services.size() - 1; i >= 0; i--) {
              ServiceRecord service = services.valueAt(i);
              final boolean sameComponent = packageName == null
                      || (service.packageName.equals(packageName)
                          && (filterByClasses == null
                              || filterByClasses.contains(service.name.getClassName())));
              if (sameComponent
                      && (service.app == null || evenPersistent || !service.app.isPersistent())) {
                  if (!doit) {
                      return true;
                  }
                  didSomething = true;
                  Slog.i(TAG, "  Force stopping service " + service);
                  if (service.app != null && !service.app.isPersistent()) {
                      service.app.services.remove(service);
                      service.app.updateBoundClientUids();
                      if (service.whitelistManager) {
                          updateWhitelistManagerLocked(service.app);
                      }
                  }
                  service.setProcess(null);
                  service.isolatedProc = null;
                  if (mTmpCollectionResults == null) {
                      mTmpCollectionResults = new ArrayList<>();
                  }
                  mTmpCollectionResults.add(service);
              }
          }
          return didSomething;
      }
  
      boolean bringDownDisabledPackageServicesLocked(String packageName, Set<String> filterByClasses,
              int userId, boolean evenPersistent, boolean doit) {
          boolean didSomething = false;
  
          if (mTmpCollectionResults != null) {
              mTmpCollectionResults.clear();
          }
  
          if (userId == UserHandle.USER_ALL) {
              for (int i = mServiceMap.size() - 1; i >= 0; i--) {
                  didSomething |= collectPackageServicesLocked(packageName, filterByClasses,
                          evenPersistent, doit, mServiceMap.valueAt(i).mServicesByInstanceName);
                  if (!doit && didSomething) {
                      return true;
                  }
                  if (doit && filterByClasses == null) {
                      forceStopPackageLocked(packageName, mServiceMap.valueAt(i).mUserId);
                  }
              }
          } else {
              ServiceMap smap = mServiceMap.get(userId);
              if (smap != null) {
                  ArrayMap<ComponentName, ServiceRecord> items = smap.mServicesByInstanceName;
                  didSomething = collectPackageServicesLocked(packageName, filterByClasses,
                          evenPersistent, doit, items);
              }
              if (doit && filterByClasses == null) {
                  forceStopPackageLocked(packageName, userId);
              }
          }
  
          if (mTmpCollectionResults != null) {
              for (int i = mTmpCollectionResults.size() - 1; i >= 0; i--) {
                  bringDownServiceLocked(mTmpCollectionResults.get(i));
              }
              mTmpCollectionResults.clear();
          }
  
          return didSomething;
      }
  
      void forceStopPackageLocked(String packageName, int userId) {
          ServiceMap smap = mServiceMap.get(userId);
          if (smap != null && smap.mActiveForegroundApps.size() > 0) {
              for (int i = smap.mActiveForegroundApps.size()-1; i >= 0; i--) {
                  ActiveForegroundApp aa = smap.mActiveForegroundApps.valueAt(i);
                  if (aa.mPackageName.equals(packageName)) {
                      smap.mActiveForegroundApps.removeAt(i);
                      smap.mActiveForegroundAppsChanged = true;
                  }
              }
              if (smap.mActiveForegroundAppsChanged) {
                  requestUpdateActiveForegroundAppsLocked(smap, 0);
              }
          }
      }
  
      void cleanUpServices(int userId, ComponentName component, Intent baseIntent) {
          ArrayList<ServiceRecord> services = new ArrayList<>();
          ArrayMap<ComponentName, ServiceRecord> alls = getServicesLocked(userId);
          for (int i = alls.size() - 1; i >= 0; i--) {
              ServiceRecord sr = alls.valueAt(i);
              if (sr.packageName.equals(component.getPackageName())) {
                  services.add(sr);
              }
          }
  
          // Take care of any running services associated with the app.
          for (int i = services.size() - 1; i >= 0; i--) {
              ServiceRecord sr = services.get(i);
              if (sr.startRequested) {
                  if ((sr.serviceInfo.flags&ServiceInfo.FLAG_STOP_WITH_TASK) != 0) {
                      Slog.i(TAG, "Stopping service " + sr.shortInstanceName + ": remove task");
                      stopServiceLocked(sr);
                  } else {
                      sr.pendingStarts.add(new ServiceRecord.StartItem(sr, true,
                              sr.getLastStartId(), baseIntent, null, 0));
                      if (sr.app != null && sr.app.thread != null) {
                          // We always run in the foreground, since this is called as
                          // part of the "remove task" UI operation.
                          try {
                              sendServiceArgsLocked(sr, true, false);
                          } catch (TransactionTooLargeException e) {
                              // Ignore, keep going.
                          }
                      }
                  }
              }
          }
      }
  
      final void killServicesLocked(ProcessRecord app, boolean allowRestart) {
          // Report disconnected services.
          if (false) {
              // XXX we are letting the client link to the service for
              // death notifications.
              if (app.services.size() > 0) {
                  Iterator<ServiceRecord> it = app.services.iterator();
                  while (it.hasNext()) {
                      ServiceRecord r = it.next();
                      ArrayMap<IBinder, ArrayList<ConnectionRecord>> connections = r.getConnections();
                      for (int conni=connections.size()-1; conni>=0; conni--) {
                          ArrayList<ConnectionRecord> cl = connections.valueAt(conni);
                          for (int i=0; i<cl.size(); i++) {
                              ConnectionRecord c = cl.get(i);
                              if (c.binding.client != app) {
                                  try {
                                      //c.conn.connected(r.className, null);
                                  } catch (Exception e) {
                                      // todo: this should be asynchronous!
                                      Slog.w(TAG, "Exception thrown disconnected servce "
                                            + r.shortInstanceName
                                            + " from app " + app.processName, e);
                                  }
                              }
                          }
                      }
                  }
              }
          }
  
          // Clean up any connections this application has to other services.
          for (int i = app.connections.size() - 1; i >= 0; i--) {
              ConnectionRecord r = app.connections.valueAt(i);
              removeConnectionLocked(r, app, null);
          }
          updateServiceConnectionActivitiesLocked(app);
          app.connections.clear();
  
          app.whitelistManager = false;
  
          // Clear app state from services.
          for (int i = app.services.size() - 1; i >= 0; i--) {
              ServiceRecord sr = app.services.valueAt(i);
              synchronized (sr.stats.getBatteryStats()) {
                  sr.stats.stopLaunchedLocked();
              }
              if (sr.app != app && sr.app != null && !sr.app.isPersistent()) {
                  sr.app.services.remove(sr);
                  sr.app.updateBoundClientUids();
              }
              sr.setProcess(null);
              sr.isolatedProc = null;
              sr.executeNesting = 0;
              sr.forceClearTracker();
              if (mDestroyingServices.remove(sr)) {
                  if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "killServices remove destroying " + sr);
              }
  
              final int numClients = sr.bindings.size();
              for (int bindingi=numClients-1; bindingi>=0; bindingi--) {
                  IntentBindRecord b = sr.bindings.valueAt(bindingi);
                  if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Killing binding " + b
                          + ": shouldUnbind=" + b.hasBound);
                  b.binder = null;
                  b.requested = b.received = b.hasBound = false;
                  // If this binding is coming from a cached process and is asking to keep
                  // the service created, then we'll kill the cached process as well -- we
                  // don't want to be thrashing around restarting processes that are only
                  // there to be cached.
                  for (int appi=b.apps.size()-1; appi>=0; appi--) {
                      final ProcessRecord proc = b.apps.keyAt(appi);
                      // If the process is already gone, skip it.
                      if (proc.killedByAm || proc.thread == null) {
                          continue;
                      }
                      // Only do this for processes that have an auto-create binding;
                      // otherwise the binding can be left, because it won't cause the
                      // service to restart.
                      final AppBindRecord abind = b.apps.valueAt(appi);
                      boolean hasCreate = false;
                      for (int conni=abind.connections.size()-1; conni>=0; conni--) {
                          ConnectionRecord conn = abind.connections.valueAt(conni);
                          if ((conn.flags&(Context.BIND_AUTO_CREATE|Context.BIND_ALLOW_OOM_MANAGEMENT
                                  |Context.BIND_WAIVE_PRIORITY)) == Context.BIND_AUTO_CREATE) {
                              hasCreate = true;
                              break;
                          }
                      }
                      if (!hasCreate) {
                          continue;
                      }
                      // XXX turned off for now until we have more time to get a better policy.
                      if (false && proc != null && !proc.isPersistent() && proc.thread != null
                              && proc.pid != 0 && proc.pid != ActivityManagerService.MY_PID
                              && proc.setProcState >= ActivityManager.PROCESS_STATE_LAST_ACTIVITY) {
                          proc.kill("bound to service " + sr.shortInstanceName
                                  + " in dying proc " + (app != null ? app.processName : "??"), true);
                      }
                  }
              }
          }
  
          ServiceMap smap = getServiceMapLocked(app.userId);
  
          // Now do remaining service cleanup.
          for (int i=app.services.size()-1; i>=0; i--) {
              ServiceRecord sr = app.services.valueAt(i);
  
              // Unless the process is persistent, this process record is going away,
              // so make sure the service is cleaned out of it.
              if (!app.isPersistent()) {
                  app.services.removeAt(i);
                  app.updateBoundClientUids();
              }
  
              // Sanity check: if the service listed for the app is not one
              // we actually are maintaining, just let it drop.
              final ServiceRecord curRec = smap.mServicesByInstanceName.get(sr.instanceName);
              if (curRec != sr) {
                  if (curRec != null) {
                      Slog.wtf(TAG, "Service " + sr + " in process " + app
                              + " not same as in map: " + curRec);
                  }
                  continue;
              }
  
              // Any services running in the application may need to be placed
              // back in the pending list.
              if (allowRestart && sr.crashCount >= mAm.mConstants.BOUND_SERVICE_MAX_CRASH_RETRY
                      && (sr.serviceInfo.applicationInfo.flags
                          &ApplicationInfo.FLAG_PERSISTENT) == 0) {
                  Slog.w(TAG, "Service crashed " + sr.crashCount
                          + " times, stopping: " + sr);
                  EventLog.writeEvent(EventLogTags.AM_SERVICE_CRASHED_TOO_MUCH,
                          sr.userId, sr.crashCount, sr.shortInstanceName, app.pid);
                  bringDownServiceLocked(sr);
              } else if (!allowRestart
                      || !mAm.mUserController.isUserRunning(sr.userId, 0)) {
                  bringDownServiceLocked(sr);
              } else {
                  boolean canceled = scheduleServiceRestartLocked(sr, true);
  
                  // Should the service remain running?  Note that in the
                  // extreme case of so many attempts to deliver a command
                  // that it failed we also will stop it here.
                  if (sr.startRequested && (sr.stopIfKilled || canceled)) {
                      if (sr.pendingStarts.size() == 0) {
                          sr.startRequested = false;
                          if (sr.tracker != null) {
                              sr.tracker.setStarted(false, mAm.mProcessStats.getMemFactorLocked(),
                                      SystemClock.uptimeMillis());
                          }
                          if (!sr.hasAutoCreateConnections()) {
                              // Whoops, no reason to restart!
                              bringDownServiceLocked(sr);
                          }
                      }
                  }
              }
          }
  
          if (!allowRestart) {
              app.services.clear();
              app.clearBoundClientUids();
  
              // Make sure there are no more restarting services for this process.
              for (int i=mRestartingServices.size()-1; i>=0; i--) {
                  ServiceRecord r = mRestartingServices.get(i);
                  if (r.processName.equals(app.processName) &&
                          r.serviceInfo.applicationInfo.uid == app.info.uid) {
                      mRestartingServices.remove(i);
                      clearRestartingIfNeededLocked(r);
                  }
              }
              for (int i=mPendingServices.size()-1; i>=0; i--) {
                  ServiceRecord r = mPendingServices.get(i);
                  if (r.processName.equals(app.processName) &&
                          r.serviceInfo.applicationInfo.uid == app.info.uid) {
                      mPendingServices.remove(i);
                  }
              }
          }
  
          // Make sure we have no more records on the stopping list.
          int i = mDestroyingServices.size();
          while (i > 0) {
              i--;
              ServiceRecord sr = mDestroyingServices.get(i);
              if (sr.app == app) {
                  sr.forceClearTracker();
                  mDestroyingServices.remove(i);
                  if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "killServices remove destroying " + sr);
              }
          }
  
          app.executingServices.clear();
      }
  
      ActivityManager.RunningServiceInfo makeRunningServiceInfoLocked(ServiceRecord r) {
          ActivityManager.RunningServiceInfo info =
              new ActivityManager.RunningServiceInfo();
          info.service = r.name;
          if (r.app != null) {
              info.pid = r.app.pid;
          }
          info.uid = r.appInfo.uid;
          info.process = r.processName;
          info.foreground = r.isForeground;
          info.activeSince = r.createRealTime;
          info.started = r.startRequested;
          info.clientCount = r.getConnections().size();
          info.crashCount = r.crashCount;
          info.lastActivityTime = r.lastActivity;
          if (r.isForeground) {
              info.flags |= ActivityManager.RunningServiceInfo.FLAG_FOREGROUND;
          }
          if (r.startRequested) {
              info.flags |= ActivityManager.RunningServiceInfo.FLAG_STARTED;
          }
          if (r.app != null && r.app.pid == ActivityManagerService.MY_PID) {
              info.flags |= ActivityManager.RunningServiceInfo.FLAG_SYSTEM_PROCESS;
          }
          if (r.app != null && r.app.isPersistent()) {
              info.flags |= ActivityManager.RunningServiceInfo.FLAG_PERSISTENT_PROCESS;
          }
  
          ArrayMap<IBinder, ArrayList<ConnectionRecord>> connections = r.getConnections();
          for (int conni = connections.size() - 1; conni >= 0; conni--) {
              ArrayList<ConnectionRecord> connl = connections.valueAt(conni);
              for (int i=0; i<connl.size(); i++) {
                  ConnectionRecord conn = connl.get(i);
                  if (conn.clientLabel != 0) {
                      info.clientPackage = conn.binding.client.info.packageName;
                      info.clientLabel = conn.clientLabel;
                      return info;
                  }
              }
          }
          return info;
      }
  
      List<ActivityManager.RunningServiceInfo> getRunningServiceInfoLocked(int maxNum, int flags,
          int callingUid, boolean allowed, boolean canInteractAcrossUsers) {
          ArrayList<ActivityManager.RunningServiceInfo> res
                  = new ArrayList<ActivityManager.RunningServiceInfo>();
  
          final long ident = Binder.clearCallingIdentity();
          try {
              if (canInteractAcrossUsers) {
                  int[] users = mAm.mUserController.getUsers();
                  for (int ui=0; ui<users.length && res.size() < maxNum; ui++) {
                      ArrayMap<ComponentName, ServiceRecord> alls = getServicesLocked(users[ui]);
                      for (int i=0; i<alls.size() && res.size() < maxNum; i++) {
                          ServiceRecord sr = alls.valueAt(i);
                          res.add(makeRunningServiceInfoLocked(sr));
                      }
                  }
  
                  for (int i=0; i<mRestartingServices.size() && res.size() < maxNum; i++) {
                      ServiceRecord r = mRestartingServices.get(i);
                      ActivityManager.RunningServiceInfo info =
                              makeRunningServiceInfoLocked(r);
                      info.restarting = r.nextRestartTime;
                      res.add(info);
                  }
              } else {
                  int userId = UserHandle.getUserId(callingUid);
                  ArrayMap<ComponentName, ServiceRecord> alls = getServicesLocked(userId);
                  for (int i=0; i<alls.size() && res.size() < maxNum; i++) {
                      ServiceRecord sr = alls.valueAt(i);
  
                      if (allowed || (sr.app != null && sr.app.uid == callingUid)) {
                          res.add(makeRunningServiceInfoLocked(sr));
                      }
                  }
  
                  for (int i=0; i<mRestartingServices.size() && res.size() < maxNum; i++) {
                      ServiceRecord r = mRestartingServices.get(i);
                      if (r.userId == userId
                          && (allowed || (r.app != null && r.app.uid == callingUid))) {
                          ActivityManager.RunningServiceInfo info =
                                  makeRunningServiceInfoLocked(r);
                          info.restarting = r.nextRestartTime;
                          res.add(info);
                      }
                  }
              }
          } finally {
              Binder.restoreCallingIdentity(ident);
          }
  
          return res;
      }
  
      public PendingIntent getRunningServiceControlPanelLocked(ComponentName name) {
          int userId = UserHandle.getUserId(Binder.getCallingUid());
          ServiceRecord r = getServiceByNameLocked(name, userId);
          if (r != null) {
              ArrayMap<IBinder, ArrayList<ConnectionRecord>> connections = r.getConnections();
              for (int conni = connections.size() - 1; conni >= 0; conni--) {
                  ArrayList<ConnectionRecord> conn = connections.valueAt(conni);
                  for (int i=0; i<conn.size(); i++) {
                      if (conn.get(i).clientIntent != null) {
                          return conn.get(i).clientIntent;
                      }
                  }
              }
          }
          return null;
      }
  
      void serviceTimeout(ProcessRecord proc) {
          String anrMessage = null;
          synchronized(mAm) {
              if (proc.isDebugging()) {
                  // The app's being debugged, ignore timeout.
                  return;
              }
              if (proc.executingServices.size() == 0 || proc.thread == null) {
                  return;
              }
              final long now = SystemClock.uptimeMillis();
              final long maxTime =  now -
                      (proc.execServicesFg ? SERVICE_TIMEOUT : SERVICE_BACKGROUND_TIMEOUT);
              ServiceRecord timeout = null;
              long nextTime = 0;
              for (int i=proc.executingServices.size()-1; i>=0; i--) {
                  ServiceRecord sr = proc.executingServices.valueAt(i);
                  if (sr.executingStart < maxTime) {
                      timeout = sr;
                      break;
                  }
                  if (sr.executingStart > nextTime) {
                      nextTime = sr.executingStart;
                  }
              }
              if (timeout != null && mAm.mProcessList.mLruProcesses.contains(proc)) {
                  Slog.w(TAG, "Timeout executing service: " + timeout);
                  StringWriter sw = new StringWriter();
                  PrintWriter pw = new FastPrintWriter(sw, false, 1024);
                  pw.println(timeout);
                  timeout.dump(pw, "    ");
                  pw.close();
                  mLastAnrDump = sw.toString();
                  mAm.mHandler.removeCallbacks(mLastAnrDumpClearer);
                  mAm.mHandler.postDelayed(mLastAnrDumpClearer, LAST_ANR_LIFETIME_DURATION_MSECS);
                  anrMessage = "executing service " + timeout.shortInstanceName;
              } else {
                  Message msg = mAm.mHandler.obtainMessage(
                          ActivityManagerService.SERVICE_TIMEOUT_MSG);
                  msg.obj = proc;
                  mAm.mHandler.sendMessageAtTime(msg, proc.execServicesFg
                          ? (nextTime+SERVICE_TIMEOUT) : (nextTime + SERVICE_BACKGROUND_TIMEOUT));
              }
          }
  
          if (anrMessage != null) {
              proc.appNotResponding(null, null, null, null, false, anrMessage);
          }
      }
  
      void serviceForegroundTimeout(ServiceRecord r) {
          ProcessRecord app;
          synchronized (mAm) {
              if (!r.fgRequired || r.destroying) {
                  return;
              }
  
              app = r.app;
              if (app != null && app.isDebugging()) {
                  // The app's being debugged; let it ride
                  return;
              }
  
              if (DEBUG_BACKGROUND_CHECK) {
                  Slog.i(TAG, "Service foreground-required timeout for " + r);
              }
              r.fgWaiting = false;
              stopServiceLocked(r);
          }
  
          if (app != null) {
              app.appNotResponding(null, null, null, null, false,
                      "Context.startForegroundService() did not then call Service.startForeground(): "
                          + r);
          }
      }
  
      public void updateServiceApplicationInfoLocked(ApplicationInfo applicationInfo) {
          final int userId = UserHandle.getUserId(applicationInfo.uid);
          ServiceMap serviceMap = mServiceMap.get(userId);
          if (serviceMap != null) {
              ArrayMap<ComponentName, ServiceRecord> servicesByName
                      = serviceMap.mServicesByInstanceName;
              for (int j = servicesByName.size() - 1; j >= 0; j--) {
                  ServiceRecord serviceRecord = servicesByName.valueAt(j);
                  if (applicationInfo.packageName.equals(serviceRecord.appInfo.packageName)) {
                      serviceRecord.appInfo = applicationInfo;
                      serviceRecord.serviceInfo.applicationInfo = applicationInfo;
                  }
              }
          }
      }
  
      void serviceForegroundCrash(ProcessRecord app, CharSequence serviceRecord) {
          mAm.crashApplication(app.uid, app.pid, app.info.packageName, app.userId,
                  "Context.startForegroundService() did not then call Service.startForeground(): "
                      + serviceRecord, false /*force*/);
      }
  
      void scheduleServiceTimeoutLocked(ProcessRecord proc) {
          if (proc.executingServices.size() == 0 || proc.thread == null) {
              return;
          }
          Message msg = mAm.mHandler.obtainMessage(
                  ActivityManagerService.SERVICE_TIMEOUT_MSG);
          msg.obj = proc;
          mAm.mHandler.sendMessageDelayed(msg,
                  proc.execServicesFg ? SERVICE_TIMEOUT : SERVICE_BACKGROUND_TIMEOUT);
      }
  
      void scheduleServiceForegroundTransitionTimeoutLocked(ServiceRecord r) {
          if (r.app.executingServices.size() == 0 || r.app.thread == null) {
              return;
          }
          Message msg = mAm.mHandler.obtainMessage(
                  ActivityManagerService.SERVICE_FOREGROUND_TIMEOUT_MSG);
          msg.obj = r;
          r.fgWaiting = true;
          mAm.mHandler.sendMessageDelayed(msg, SERVICE_START_FOREGROUND_TIMEOUT);
      }
  
      final class ServiceDumper {
          private final FileDescriptor fd;
          private final PrintWriter pw;
          private final String[] args;
          private final boolean dumpAll;
          private final String dumpPackage;
          private final ItemMatcher matcher;
          private final ArrayList<ServiceRecord> services = new ArrayList<>();
  
          private final long nowReal = SystemClock.elapsedRealtime();
  
          private boolean needSep = false;
          private boolean printedAnything = false;
          private boolean printed = false;
  
          /**
           * Note: do not call directly, use {@link #newServiceDumperLocked} instead (this
           * must be called with the lock held).
           */
          ServiceDumper(FileDescriptor fd, PrintWriter pw, String[] args,
                  int opti, boolean dumpAll, String dumpPackage) {
              this.fd = fd;
              this.pw = pw;
              this.args = args;
              this.dumpAll = dumpAll;
              this.dumpPackage = dumpPackage;
              matcher = new ItemMatcher();
              matcher.build(args, opti);
  
              final int[] users = mAm.mUserController.getUsers();
              for (int user : users) {
                  ServiceMap smap = getServiceMapLocked(user);
                  if (smap.mServicesByInstanceName.size() > 0) {
                      for (int si=0; si<smap.mServicesByInstanceName.size(); si++) {
                          ServiceRecord r = smap.mServicesByInstanceName.valueAt(si);
                          if (!matcher.match(r, r.name)) {
                              continue;
                          }
                          if (dumpPackage != null && !dumpPackage.equals(r.appInfo.packageName)) {
                              continue;
                          }
                          services.add(r);
                      }
                  }
              }
          }
  
          private void dumpHeaderLocked() {
              pw.println("ACTIVITY MANAGER SERVICES (dumpsys activity services)");
              if (mLastAnrDump != null) {
                  pw.println("  Last ANR service:");
                  pw.print(mLastAnrDump);
                  pw.println();
              }
          }
  
          void dumpLocked() {
              dumpHeaderLocked();
  
              try {
                  int[] users = mAm.mUserController.getUsers();
                  for (int user : users) {
                      // Find the first service for this user.
                      int serviceIdx = 0;
                      while (serviceIdx < services.size() && services.get(serviceIdx).userId != user) {
                          serviceIdx++;
                      }
                      printed = false;
                      if (serviceIdx < services.size()) {
                          needSep = false;
                          while (serviceIdx < services.size()) {
                              ServiceRecord r = services.get(serviceIdx);
                              serviceIdx++;
                              if (r.userId != user) {
                                  break;
                              }
                              dumpServiceLocalLocked(r);
                          }
                          needSep |= printed;
                      }
  
                      dumpUserRemainsLocked(user);
                  }
              } catch (Exception e) {
                  Slog.w(TAG, "Exception in dumpServicesLocked", e);
              }
  
              dumpRemainsLocked();
          }
  
          void dumpWithClient() {
              synchronized(mAm) {
                  dumpHeaderLocked();
              }
  
              try {
                  int[] users = mAm.mUserController.getUsers();
                  for (int user : users) {
                      // Find the first service for this user.
                      int serviceIdx = 0;
                      while (serviceIdx < services.size() && services.get(serviceIdx).userId != user) {
                          serviceIdx++;
                      }
                      printed = false;
                      if (serviceIdx < services.size()) {
                          needSep = false;
                          while (serviceIdx < services.size()) {
                              ServiceRecord r = services.get(serviceIdx);
                              serviceIdx++;
                              if (r.userId != user) {
                                  break;
                              }
                              synchronized(mAm) {
                                  dumpServiceLocalLocked(r);
                              }
                              dumpServiceClient(r);
                          }
                          needSep |= printed;
                      }
  
                      synchronized(mAm) {
                          dumpUserRemainsLocked(user);
                      }
                  }
              } catch (Exception e) {
                  Slog.w(TAG, "Exception in dumpServicesLocked", e);
              }
  
              synchronized(mAm) {
                  dumpRemainsLocked();
              }
          }
  
          private void dumpUserHeaderLocked(int user) {
              if (!printed) {
                  if (printedAnything) {
                      pw.println();
                  }
                  pw.println("  User " + user + " active services:");
                  printed = true;
              }
              printedAnything = true;
              if (needSep) {
                  pw.println();
              }
          }
  
          private void dumpServiceLocalLocked(ServiceRecord r) {
              dumpUserHeaderLocked(r.userId);
              pw.print("  * ");
              pw.println(r);
              if (dumpAll) {
                  r.dump(pw, "    ");
                  needSep = true;
              } else {
                  pw.print("    app=");
                  pw.println(r.app);
                  pw.print("    created=");
                  TimeUtils.formatDuration(r.createRealTime, nowReal, pw);
                  pw.print(" started=");
                  pw.print(r.startRequested);
                  pw.print(" connections=");
                  ArrayMap<IBinder, ArrayList<ConnectionRecord>> connections = r.getConnections();
                  pw.println(connections.size());
                  if (connections.size() > 0) {
                      pw.println("    Connections:");
                      for (int conni = 0; conni < connections.size(); conni++) {
                          ArrayList<ConnectionRecord> clist = connections.valueAt(conni);
                          for (int i = 0; i < clist.size(); i++) {
                              ConnectionRecord conn = clist.get(i);
                              pw.print("      ");
                              pw.print(conn.binding.intent.intent.getIntent()
                                      .toShortString(false, false, false, false));
                              pw.print(" -> ");
                              ProcessRecord proc = conn.binding.client;
                              pw.println(proc != null ? proc.toShortString() : "null");
                          }
                      }
                  }
              }
          }
  
          private void dumpServiceClient(ServiceRecord r) {
              final ProcessRecord proc = r.app;
              if (proc == null) {
                  return;
              }
              final IApplicationThread thread = proc.thread;
              if (thread == null) {
                  return;
              }
              pw.println("    Client:");
              pw.flush();
              try {
                  TransferPipe tp = new TransferPipe();
                  try {
                      thread.dumpService(tp.getWriteFd(), r, args);
                      tp.setBufferPrefix("      ");
                      // Short timeout, since blocking here can
                      // deadlock with the application.
                      tp.go(fd, 2000);
                  } finally {
                      tp.kill();
                  }
              } catch (IOException e) {
                  pw.println("      Failure while dumping the service: " + e);
              } catch (RemoteException e) {
                  pw.println("      Got a RemoteException while dumping the service");
              }
              needSep = true;
          }
  
          private void dumpUserRemainsLocked(int user) {
              ServiceMap smap = getServiceMapLocked(user);
              printed = false;
              for (int si=0, SN=smap.mDelayedStartList.size(); si<SN; si++) {
                  ServiceRecord r = smap.mDelayedStartList.get(si);
                  if (!matcher.match(r, r.name)) {
                      continue;
                  }
                  if (dumpPackage != null && !dumpPackage.equals(r.appInfo.packageName)) {
                      continue;
                  }
                  if (!printed) {
                      if (printedAnything) {
                          pw.println();
                      }
                      pw.println("  User " + user + " delayed start services:");
                      printed = true;
                  }
                  printedAnything = true;
                  pw.print("  * Delayed start "); pw.println(r);
              }
              printed = false;
              for (int si=0, SN=smap.mStartingBackground.size(); si<SN; si++) {
                  ServiceRecord r = smap.mStartingBackground.get(si);
                  if (!matcher.match(r, r.name)) {
                      continue;
                  }
                  if (dumpPackage != null && !dumpPackage.equals(r.appInfo.packageName)) {
                      continue;
                  }
                  if (!printed) {
                      if (printedAnything) {
                          pw.println();
                      }
                      pw.println("  User " + user + " starting in background:");
                      printed = true;
                  }
                  printedAnything = true;
                  pw.print("  * Starting bg "); pw.println(r);
              }
          }
  
          private void dumpRemainsLocked() {
              if (mPendingServices.size() > 0) {
                  printed = false;
                  for (int i=0; i<mPendingServices.size(); i++) {
                      ServiceRecord r = mPendingServices.get(i);
                      if (!matcher.match(r, r.name)) {
                          continue;
                      }
                      if (dumpPackage != null && !dumpPackage.equals(r.appInfo.packageName)) {
                          continue;
                      }
                      printedAnything = true;
                      if (!printed) {
                          if (needSep) pw.println();
                          needSep = true;
                          pw.println("  Pending services:");
                          printed = true;
                      }
                      pw.print("  * Pending "); pw.println(r);
                      r.dump(pw, "    ");
                  }
                  needSep = true;
              }
  
              if (mRestartingServices.size() > 0) {
                  printed = false;
                  for (int i=0; i<mRestartingServices.size(); i++) {
                      ServiceRecord r = mRestartingServices.get(i);
                      if (!matcher.match(r, r.name)) {
                          continue;
                      }
                      if (dumpPackage != null && !dumpPackage.equals(r.appInfo.packageName)) {
                          continue;
                      }
                      printedAnything = true;
                      if (!printed) {
                          if (needSep) pw.println();
                          needSep = true;
                          pw.println("  Restarting services:");
                          printed = true;
                      }
                      pw.print("  * Restarting "); pw.println(r);
                      r.dump(pw, "    ");
                  }
                  needSep = true;
              }
  
              if (mDestroyingServices.size() > 0) {
                  printed = false;
                  for (int i=0; i< mDestroyingServices.size(); i++) {
                      ServiceRecord r = mDestroyingServices.get(i);
                      if (!matcher.match(r, r.name)) {
                          continue;
                      }
                      if (dumpPackage != null && !dumpPackage.equals(r.appInfo.packageName)) {
                          continue;
                      }
                      printedAnything = true;
                      if (!printed) {
                          if (needSep) pw.println();
                          needSep = true;
                          pw.println("  Destroying services:");
                          printed = true;
                      }
                      pw.print("  * Destroy "); pw.println(r);
                      r.dump(pw, "    ");
                  }
                  needSep = true;
              }
  
              if (dumpAll) {
                  printed = false;
                  for (int ic=0; ic<mServiceConnections.size(); ic++) {
                      ArrayList<ConnectionRecord> r = mServiceConnections.valueAt(ic);
                      for (int i=0; i<r.size(); i++) {
                          ConnectionRecord cr = r.get(i);
                          if (!matcher.match(cr.binding.service, cr.binding.service.name)) {
                              continue;
                          }
                          if (dumpPackage != null && (cr.binding.client == null
                                  || !dumpPackage.equals(cr.binding.client.info.packageName))) {
                              continue;
                          }
                          printedAnything = true;
                          if (!printed) {
                              if (needSep) pw.println();
                              needSep = true;
                              pw.println("  Connection bindings to services:");
                              printed = true;
                          }
                          pw.print("  * "); pw.println(cr);
                          cr.dump(pw, "    ");
                      }
                  }
              }
  
              if (matcher.all) {
                  final long nowElapsed = SystemClock.elapsedRealtime();
                  final int[] users = mAm.mUserController.getUsers();
                  for (int user : users) {
                      boolean printedUser = false;
                      ServiceMap smap = mServiceMap.get(user);
                      if (smap == null) {
                          continue;
                      }
                      for (int i = smap.mActiveForegroundApps.size() - 1; i >= 0; i--) {
                          ActiveForegroundApp aa = smap.mActiveForegroundApps.valueAt(i);
                          if (dumpPackage != null && !dumpPackage.equals(aa.mPackageName)) {
                              continue;
                          }
                          if (!printedUser) {
                              printedUser = true;
                              printedAnything = true;
                              if (needSep) pw.println();
                              needSep = true;
                              pw.print("Active foreground apps - user ");
                              pw.print(user);
                              pw.println(":");
                          }
                          pw.print("  #");
                          pw.print(i);
                          pw.print(": ");
                          pw.println(aa.mPackageName);
                          if (aa.mLabel != null) {
                              pw.print("    mLabel=");
                              pw.println(aa.mLabel);
                          }
                          pw.print("    mNumActive=");
                          pw.print(aa.mNumActive);
                          pw.print(" mAppOnTop=");
                          pw.print(aa.mAppOnTop);
                          pw.print(" mShownWhileTop=");
                          pw.print(aa.mShownWhileTop);
                          pw.print(" mShownWhileScreenOn=");
                          pw.println(aa.mShownWhileScreenOn);
                          pw.print("    mStartTime=");
                          TimeUtils.formatDuration(aa.mStartTime - nowElapsed, pw);
                          pw.print(" mStartVisibleTime=");
                          TimeUtils.formatDuration(aa.mStartVisibleTime - nowElapsed, pw);
                          pw.println();
                          if (aa.mEndTime != 0) {
                              pw.print("    mEndTime=");
                              TimeUtils.formatDuration(aa.mEndTime - nowElapsed, pw);
                              pw.println();
                          }
                      }
                      if (smap.hasMessagesOrCallbacks()) {
                          if (needSep) {
                              pw.println();
                          }
                          printedAnything = true;
                          needSep = true;
                          pw.print("  Handler - user ");
                          pw.print(user);
                          pw.println(":");
                          smap.dumpMine(new PrintWriterPrinter(pw), "    ");
                      }
                  }
              }
  
              if (!printedAnything) {
                  pw.println("  (nothing)");
              }
          }
      }
  
      ServiceDumper newServiceDumperLocked(FileDescriptor fd, PrintWriter pw, String[] args,
              int opti, boolean dumpAll, String dumpPackage) {
          return new ServiceDumper(fd, pw, args, opti, dumpAll, dumpPackage);
      }
  
      protected void writeToProto(ProtoOutputStream proto, long fieldId) {
          synchronized (mAm) {
              final long outterToken = proto.start(fieldId);
              int[] users = mAm.mUserController.getUsers();
              for (int user : users) {
                  ServiceMap smap = mServiceMap.get(user);
                  if (smap == null) {
                      continue;
                  }
                  long token = proto.start(ActiveServicesProto.SERVICES_BY_USERS);
                  proto.write(ActiveServicesProto.ServicesByUser.USER_ID, user);
                  ArrayMap<ComponentName, ServiceRecord> alls = smap.mServicesByInstanceName;
                  for (int i=0; i<alls.size(); i++) {
                      alls.valueAt(i).writeToProto(proto,
                              ActiveServicesProto.ServicesByUser.SERVICE_RECORDS);
                  }
                  proto.end(token);
              }
              proto.end(outterToken);
          }
      }
  
      /**
       * There are three ways to call this:
       *  - no service specified: dump all the services
       *  - a flattened component name that matched an existing service was specified as the
       *    first arg: dump that one service
       *  - the first arg isn't the flattened component name of an existing service:
       *    dump all services whose component contains the first arg as a substring
       */
      protected boolean dumpService(FileDescriptor fd, PrintWriter pw, final String name,
              String[] args, int opti, boolean dumpAll) {
          final ArrayList<ServiceRecord> services = new ArrayList<>();
  
          final Predicate<ServiceRecord> filter = DumpUtils.filterRecord(name);
  
          synchronized (mAm) {
              int[] users = mAm.mUserController.getUsers();
  
              for (int user : users) {
                  ServiceMap smap = mServiceMap.get(user);
                  if (smap == null) {
                      continue;
                  }
                  ArrayMap<ComponentName, ServiceRecord> alls = smap.mServicesByInstanceName;
                  for (int i=0; i<alls.size(); i++) {
                      ServiceRecord r1 = alls.valueAt(i);
  
                      if (filter.test(r1)) {
                          services.add(r1);
                      }
                  }
              }
          }
  
          if (services.size() <= 0) {
              return false;
          }
  
          // Sort by component name.
          services.sort(Comparator.comparing(WithComponentName::getComponentName));
  
          boolean needSep = false;
          for (int i=0; i<services.size(); i++) {
              if (needSep) {
                  pw.println();
              }
              needSep = true;
              dumpService("", fd, pw, services.get(i), args, dumpAll);
          }
          return true;
      }
  
      /**
       * Invokes IApplicationThread.dumpService() on the thread of the specified service if
       * there is a thread associated with the service.
       */
      private void dumpService(String prefix, FileDescriptor fd, PrintWriter pw,
              final ServiceRecord r, String[] args, boolean dumpAll) {
          String innerPrefix = prefix + "  ";
          synchronized (mAm) {
              pw.print(prefix); pw.print("SERVICE ");
                      pw.print(r.shortInstanceName); pw.print(" ");
                      pw.print(Integer.toHexString(System.identityHashCode(r)));
                      pw.print(" pid=");
                      if (r.app != null) pw.println(r.app.pid);
                      else pw.println("(not running)");
              if (dumpAll) {
                  r.dump(pw, innerPrefix);
              }
          }
          if (r.app != null && r.app.thread != null) {
              pw.print(prefix); pw.println("  Client:");
              pw.flush();
              try {
                  TransferPipe tp = new TransferPipe();
                  try {
                      r.app.thread.dumpService(tp.getWriteFd(), r, args);
                      tp.setBufferPrefix(prefix + "    ");
                      tp.go(fd);
                  } finally {
                      tp.kill();
                  }
              } catch (IOException e) {
                  pw.println(prefix + "    Failure while dumping the service: " + e);
              } catch (RemoteException e) {
                  pw.println(prefix + "    Got a RemoteException while dumping the service");
              }
          }
      }
  }
  