services/core/java/com/android/server/am/ProcessRecord.java

   1 /*
   2  * Copyright (C) 2006 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.server.am;
  18
  19 import static android.app.ActivityManager.PROCESS_STATE_NONEXISTENT;
  20 import static com.android.server.am.ActivityManagerDebugConfig.TAG_AM;
  21 import static com.android.server.am.ActivityManagerDebugConfig.TAG_WITH_CLASS_NAME;
  22
  23 import android.util.ArraySet;
  24 import android.util.DebugUtils;
  25 import android.util.EventLog;
  26 import android.util.Slog;
  27 import com.android.internal.app.procstats.ProcessStats;
  28 import com.android.internal.app.procstats.ProcessState;
  29 import com.android.internal.os.BatteryStatsImpl;
  30
  31 import android.app.ActivityManager;
  32 import android.app.Dialog;
  33 import android.app.IApplicationThread;
  34 import android.app.IInstrumentationWatcher;
  35 import android.app.IUiAutomationConnection;
  36 import android.content.ComponentName;
  37 import android.content.Context;
  38 import android.content.pm.ApplicationInfo;
  39 import android.content.res.CompatibilityInfo;
  40 import android.os.Binder;
  41 import android.os.Bundle;
  42 import android.os.IBinder;
  43 import android.os.Process;
  44 import android.os.RemoteException;
  45 import android.os.SystemClock;
  46 import android.os.Trace;
  47 import android.os.UserHandle;
  48 import android.util.ArrayMap;
  49 import android.util.PrintWriterPrinter;
  50 import android.util.TimeUtils;
  51
  52 import java.io.PrintWriter;
  53 import java.util.ArrayList;
  54
  55 /**
  56  * Full information about a particular process that
  57  * is currently running.
  58  */
  59 final class ProcessRecord {
  60     private static final String TAG = TAG_WITH_CLASS_NAME ? "ProcessRecord" : TAG_AM;
  61
  62     private final BatteryStatsImpl mBatteryStats; // where to collect runtime statistics
  63     final ApplicationInfo info; // all about the first app in the process
  64     final boolean isolated;     // true if this is a special isolated process
  65     final int uid;              // uid of process; may be different from 'info' if isolated
  66     final int userId;           // user of process.
  67     final String processName;   // name of the process
  68     // List of packages running in the process
  69     final ArrayMap<String, ProcessStats.ProcessStateHolder> pkgList = new ArrayMap<>();
  70     UidRecord uidRecord;        // overall state of process's uid.
  71     ArraySet<String> pkgDeps;   // additional packages we have a dependency on
  72     IApplicationThread thread;  // the actual proc...  may be null only if
  73                                 // 'persistent' is true (in which case we
  74                                 // are in the process of launching the app)
  75     ProcessState baseProcessTracker;
  76     BatteryStatsImpl.Uid.Proc curProcBatteryStats;
  77     int pid;                    // The process of this application; 0 if none
  78     int[] gids;                 // The gids this process was launched with
  79     String requiredAbi;         // The ABI this process was launched with
  80     String instructionSet;      // The instruction set this process was launched with
  81     boolean starting;           // True if the process is being started
  82     long lastActivityTime;      // For managing the LRU list
  83     long lastPssTime;           // Last time we retrieved PSS data
  84     long nextPssTime;           // Next time we want to request PSS data
  85     long lastStateTime;         // Last time setProcState changed
  86     long initialIdlePss;        // Initial memory pss of process for idle maintenance.
  87     long lastPss;               // Last computed memory pss.
  88     long lastSwapPss;           // Last computed SwapPss.
  89     long lastCachedPss;         // Last computed pss when in cached state.
  90     long lastCachedSwapPss;     // Last computed SwapPss when in cached state.
  91     int maxAdj;                 // Maximum OOM adjustment for this process
  92     int curRawAdj;              // Current OOM unlimited adjustment for this process
  93     int setRawAdj;              // Last set OOM unlimited adjustment for this process
  94     int curAdj;                 // Current OOM adjustment for this process
  95     int setAdj;                 // Last set OOM adjustment for this process
  96     int curSchedGroup;          // Currently desired scheduling class
  97     int setSchedGroup;          // Last set to background scheduling class
  98     int trimMemoryLevel;        // Last selected memory trimming level
  99     int curProcState = PROCESS_STATE_NONEXISTENT; // Currently computed process state
 100     int repProcState = PROCESS_STATE_NONEXISTENT; // Last reported process state
 101     int setProcState = PROCESS_STATE_NONEXISTENT; // Last set process state in process tracker
 102     int pssProcState = PROCESS_STATE_NONEXISTENT; // Currently requesting pss for
 103     boolean serviceb;           // Process currently is on the service B list
 104     boolean serviceHighRam;     // We are forcing to service B list due to its RAM use
 105     boolean setIsForeground;    // Running foreground UI when last set?
 106     boolean notCachedSinceIdle; // Has this process not been in a cached state since last idle?
 107     boolean hasClientActivities;  // Are there any client services with activities?
 108     boolean hasStartedServices; // Are there any started services running in this process?
 109     boolean foregroundServices; // Running any services that are foreground?
 110     boolean foregroundActivities; // Running any activities that are foreground?
 111     boolean repForegroundActivities; // Last reported foreground activities.
 112     boolean systemNoUi;         // This is a system process, but not currently showing UI.
 113     boolean hasShownUi;         // Has UI been shown in this process since it was started?
 114     boolean pendingUiClean;     // Want to clean up resources from showing UI?
 115     boolean hasAboveClient;     // Bound using BIND_ABOVE_CLIENT, so want to be lower
 116     boolean treatLikeActivity;  // Bound using BIND_TREAT_LIKE_ACTIVITY
 117     boolean bad;                // True if disabled in the bad process list
 118     boolean killedByAm;         // True when proc has been killed by activity manager, not for RAM
 119     boolean killed;             // True once we know the process has been killed
 120     boolean procStateChanged;   // Keep track of whether we changed 'setAdj'.
 121     boolean reportedInteraction;// Whether we have told usage stats about it being an interaction
 122     boolean unlocked;           // True when proc was started in user unlocked state
 123     long interactionEventTime;  // The time we sent the last interaction event
 124     long fgInteractionTime;     // When we became foreground for interaction purposes
 125     String waitingToKill;       // Process is waiting to be killed when in the bg, and reason
 126     IBinder forcingToForeground;// Token that is forcing this process to be foreground
 127     int adjSeq;                 // Sequence id for identifying oom_adj assignment cycles
 128     int lruSeq;                 // Sequence id for identifying LRU update cycles
 129     CompatibilityInfo compat;   // last used compatibility mode
 130     IBinder.DeathRecipient deathRecipient; // Who is watching for the death.
 131     ComponentName instrumentationClass;// class installed to instrument app
 132     ApplicationInfo instrumentationInfo; // the application being instrumented
 133     String instrumentationProfileFile; // where to save profiling
 134     IInstrumentationWatcher instrumentationWatcher; // who is waiting
 135     IUiAutomationConnection instrumentationUiAutomationConnection; // Connection to use the UI introspection APIs.
 136     Bundle instrumentationArguments;// as given to us
 137     ComponentName instrumentationResultClass;// copy of instrumentationClass
 138     boolean usingWrapper;       // Set to true when process was launched with a wrapper attached
 139     BroadcastRecord curReceiver;// receiver currently running in the app
 140     long lastWakeTime;          // How long proc held wake lock at last check
 141     long lastCpuTime;           // How long proc has run CPU at last check
 142     long curCpuTime;            // How long proc has run CPU most recently
 143     long lastRequestedGc;       // When we last asked the app to do a gc
 144     long lastLowMemory;         // When we last told the app that memory is low
 145     long lastProviderTime;      // The last time someone else was using a provider in this process.
 146     boolean reportLowMemory;    // Set to true when waiting to report low mem
 147     boolean empty;              // Is this an empty background process?
 148     boolean cached;             // Is this a cached process?
 149     String adjType;             // Debugging: primary thing impacting oom_adj.
 150     int adjTypeCode;            // Debugging: adj code to report to app.
 151     Object adjSource;           // Debugging: option dependent object.
 152     int adjSourceProcState;     // Debugging: proc state of adjSource's process.
 153     Object adjTarget;           // Debugging: target component impacting oom_adj.
 154     Runnable crashHandler;      // Optional local handler to be invoked in the process crash.
 155
 156     // all activities running in the process
 157     final ArrayList<ActivityRecord> activities = new ArrayList<>();
 158     // all ServiceRecord running in this process
 159     final ArraySet<ServiceRecord> services = new ArraySet<>();
 160     // services that are currently executing code (need to remain foreground).
 161     final ArraySet<ServiceRecord> executingServices = new ArraySet<>();
 162     // All ConnectionRecord this process holds
 163     final ArraySet<ConnectionRecord> connections = new ArraySet<>();
 164     // all IIntentReceivers that are registered from this process.
 165     final ArraySet<ReceiverList> receivers = new ArraySet<>();
 166     // class (String) -> ContentProviderRecord
 167     final ArrayMap<String, ContentProviderRecord> pubProviders = new ArrayMap<>();
 168     // All ContentProviderRecord process is using
 169     final ArrayList<ContentProviderConnection> conProviders = new ArrayList<>();
 170
 171     boolean execServicesFg;     // do we need to be executing services in the foreground?
 172     boolean persistent;         // always keep this application running?
 173     boolean crashing;           // are we in the process of crashing?
 174     Dialog crashDialog;         // dialog being displayed due to crash.
 175     boolean forceCrashReport;   // suppress normal auto-dismiss of crash dialog & report UI?
 176     boolean notResponding;      // does the app have a not responding dialog?
 177     Dialog anrDialog;           // dialog being displayed due to app not resp.
 178     boolean removed;            // has app package been removed from device?
 179     boolean debugging;          // was app launched for debugging?
 180     boolean waitedForDebugger;  // has process show wait for debugger dialog?
 181     Dialog waitDialog;          // current wait for debugger dialog
 182
 183     String shortStringName;     // caching of toShortString() result.
 184     String stringName;          // caching of toString() result.
 185
 186     // These reports are generated & stored when an app gets into an error condition.
 187     // They will be "null" when all is OK.
 188     ActivityManager.ProcessErrorStateInfo crashingReport;
 189     ActivityManager.ProcessErrorStateInfo notRespondingReport;
 190
 191     // Who will be notified of the error. This is usually an activity in the
 192     // app that installed the package.
 193     ComponentName errorReportReceiver;
 194
 195     // Process is currently hosting a backup agent for backup or restore
 196     public boolean inFullBackup;
 197
 198     void dump(PrintWriter pw, String prefix) {
 199         final long now = SystemClock.uptimeMillis();
 200
 201         pw.print(prefix); pw.print("user #"); pw.print(userId);
 202                 pw.print(" uid="); pw.print(info.uid);
 203         if (uid != info.uid) {
 204             pw.print(" ISOLATED uid="); pw.print(uid);
 205         }
 206         pw.print(" gids={");
 207         if (gids != null) {
 208             for (int gi=0; gi<gids.length; gi++) {
 209                 if (gi != 0) pw.print(", ");
 210                 pw.print(gids[gi]);
 211
 212             }
 213         }
 214         pw.println("}");
 215         pw.print(prefix); pw.print("requiredAbi="); pw.print(requiredAbi);
 216                 pw.print(" instructionSet="); pw.println(instructionSet);
 217         if (info.className != null) {
 218             pw.print(prefix); pw.print("class="); pw.println(info.className);
 219         }
 220         if (info.manageSpaceActivityName != null) {
 221             pw.print(prefix); pw.print("manageSpaceActivityName=");
 222             pw.println(info.manageSpaceActivityName);
 223         }
 224         pw.print(prefix); pw.print("dir="); pw.print(info.sourceDir);
 225                 pw.print(" publicDir="); pw.print(info.publicSourceDir);
 226                 pw.print(" data="); pw.println(info.dataDir);
 227         pw.print(prefix); pw.print("packageList={");
 228         for (int i=0; i<pkgList.size(); i++) {
 229             if (i > 0) pw.print(", ");
 230             pw.print(pkgList.keyAt(i));
 231         }
 232         pw.println("}");
 233         if (pkgDeps != null) {
 234             pw.print(prefix); pw.print("packageDependencies={");
 235             for (int i=0; i<pkgDeps.size(); i++) {
 236                 if (i > 0) pw.print(", ");
 237                 pw.print(pkgDeps.valueAt(i));
 238             }
 239             pw.println("}");
 240         }
 241         pw.print(prefix); pw.print("compat="); pw.println(compat);
 242         if (instrumentationClass != null || instrumentationProfileFile != null
 243                 || instrumentationArguments != null) {
 244             pw.print(prefix); pw.print("instrumentationClass=");
 245                     pw.print(instrumentationClass);
 246                     pw.print(" instrumentationProfileFile=");
 247                     pw.println(instrumentationProfileFile);
 248             pw.print(prefix); pw.print("instrumentationArguments=");
 249                     pw.println(instrumentationArguments);
 250             pw.print(prefix); pw.print("instrumentationInfo=");
 251                     pw.println(instrumentationInfo);
 252             if (instrumentationInfo != null) {
 253                 instrumentationInfo.dump(new PrintWriterPrinter(pw), prefix + "  ");
 254             }
 255         }
 256         pw.print(prefix); pw.print("thread="); pw.println(thread);
 257         pw.print(prefix); pw.print("pid="); pw.print(pid); pw.print(" starting=");
 258                 pw.println(starting);
 259         pw.print(prefix); pw.print("lastActivityTime=");
 260                 TimeUtils.formatDuration(lastActivityTime, now, pw);
 261                 pw.print(" lastPssTime=");
 262                 TimeUtils.formatDuration(lastPssTime, now, pw);
 263                 pw.print(" nextPssTime=");
 264                 TimeUtils.formatDuration(nextPssTime, now, pw);
 265                 pw.println();
 266         pw.print(prefix); pw.print("adjSeq="); pw.print(adjSeq);
 267                 pw.print(" lruSeq="); pw.print(lruSeq);
 268                 pw.print(" lastPss="); DebugUtils.printSizeValue(pw, lastPss*1024);
 269                 pw.print(" lastSwapPss="); DebugUtils.printSizeValue(pw, lastSwapPss*1024);
 270                 pw.print(" lastCachedPss="); DebugUtils.printSizeValue(pw, lastCachedPss*1024);
 271                 pw.print(" lastCachedSwapPss="); DebugUtils.printSizeValue(pw, lastCachedSwapPss*1024);
 272                 pw.println();
 273         pw.print(prefix); pw.print("cached="); pw.print(cached);
 274                 pw.print(" empty="); pw.println(empty);
 275         if (serviceb) {
 276             pw.print(prefix); pw.print("serviceb="); pw.print(serviceb);
 277                     pw.print(" serviceHighRam="); pw.println(serviceHighRam);
 278         }
 279         if (notCachedSinceIdle) {
 280             pw.print(prefix); pw.print("notCachedSinceIdle="); pw.print(notCachedSinceIdle);
 281                     pw.print(" initialIdlePss="); pw.println(initialIdlePss);
 282         }
 283         pw.print(prefix); pw.print("oom: max="); pw.print(maxAdj);
 284                 pw.print(" curRaw="); pw.print(curRawAdj);
 285                 pw.print(" setRaw="); pw.print(setRawAdj);
 286                 pw.print(" cur="); pw.print(curAdj);
 287                 pw.print(" set="); pw.println(setAdj);
 288         pw.print(prefix); pw.print("curSchedGroup="); pw.print(curSchedGroup);
 289                 pw.print(" setSchedGroup="); pw.print(setSchedGroup);
 290                 pw.print(" systemNoUi="); pw.print(systemNoUi);
 291                 pw.print(" trimMemoryLevel="); pw.println(trimMemoryLevel);
 292         pw.print(prefix); pw.print("curProcState="); pw.print(curProcState);
 293                 pw.print(" repProcState="); pw.print(repProcState);
 294                 pw.print(" pssProcState="); pw.print(pssProcState);
 295                 pw.print(" setProcState="); pw.print(setProcState);
 296                 pw.print(" lastStateTime=");
 297                 TimeUtils.formatDuration(lastStateTime, now, pw);
 298                 pw.println();
 299         if (hasShownUi || pendingUiClean || hasAboveClient || treatLikeActivity) {
 300             pw.print(prefix); pw.print("hasShownUi="); pw.print(hasShownUi);
 301                     pw.print(" pendingUiClean="); pw.print(pendingUiClean);
 302                     pw.print(" hasAboveClient="); pw.print(hasAboveClient);
 303                     pw.print(" treatLikeActivity="); pw.println(treatLikeActivity);
 304         }
 305         if (setIsForeground || foregroundServices || forcingToForeground != null) {
 306             pw.print(prefix); pw.print("setIsForeground="); pw.print(setIsForeground);
 307                     pw.print(" foregroundServices="); pw.print(foregroundServices);
 308                     pw.print(" forcingToForeground="); pw.println(forcingToForeground);
 309         }
 310         if (reportedInteraction || fgInteractionTime != 0) {
 311             pw.print(prefix); pw.print("reportedInteraction=");
 312             pw.print(reportedInteraction);
 313             if (interactionEventTime != 0) {
 314                 pw.print(" time=");
 315                 TimeUtils.formatDuration(interactionEventTime, SystemClock.elapsedRealtime(), pw);
 316             }
 317             if (fgInteractionTime != 0) {
 318                 pw.print(" fgInteractionTime=");
 319                 TimeUtils.formatDuration(fgInteractionTime, SystemClock.elapsedRealtime(), pw);
 320             }
 321             pw.println();
 322         }
 323         if (persistent || removed) {
 324             pw.print(prefix); pw.print("persistent="); pw.print(persistent);
 325                     pw.print(" removed="); pw.println(removed);
 326         }
 327         if (hasClientActivities || foregroundActivities || repForegroundActivities) {
 328             pw.print(prefix); pw.print("hasClientActivities="); pw.print(hasClientActivities);
 329                     pw.print(" foregroundActivities="); pw.print(foregroundActivities);
 330                     pw.print(" (rep="); pw.print(repForegroundActivities); pw.println(")");
 331         }
 332         if (lastProviderTime > 0) {
 333             pw.print(prefix); pw.print("lastProviderTime=");
 334             TimeUtils.formatDuration(lastProviderTime, now, pw);
 335             pw.println();
 336         }
 337         if (hasStartedServices) {
 338             pw.print(prefix); pw.print("hasStartedServices="); pw.println(hasStartedServices);
 339         }
 340         if (setProcState >= ActivityManager.PROCESS_STATE_SERVICE) {
 341             long wtime;
 342             synchronized (mBatteryStats) {
 343                 wtime = mBatteryStats.getProcessWakeTime(info.uid,
 344                         pid, SystemClock.elapsedRealtime());
 345             }
 346             pw.print(prefix); pw.print("lastWakeTime="); pw.print(lastWakeTime);
 347                     pw.print(" timeUsed=");
 348                     TimeUtils.formatDuration(wtime-lastWakeTime, pw); pw.println("");
 349             pw.print(prefix); pw.print("lastCpuTime="); pw.print(lastCpuTime);
 350                     pw.print(" timeUsed=");
 351                     TimeUtils.formatDuration(curCpuTime-lastCpuTime, pw); pw.println("");
 352         }
 353         pw.print(prefix); pw.print("lastRequestedGc=");
 354                 TimeUtils.formatDuration(lastRequestedGc, now, pw);
 355                 pw.print(" lastLowMemory=");
 356                 TimeUtils.formatDuration(lastLowMemory, now, pw);
 357                 pw.print(" reportLowMemory="); pw.println(reportLowMemory);
 358         if (killed || killedByAm || waitingToKill != null) {
 359             pw.print(prefix); pw.print("killed="); pw.print(killed);
 360                     pw.print(" killedByAm="); pw.print(killedByAm);
 361                     pw.print(" waitingToKill="); pw.println(waitingToKill);
 362         }
 363         if (debugging || crashing || crashDialog != null || notResponding
 364                 || anrDialog != null || bad) {
 365             pw.print(prefix); pw.print("debugging="); pw.print(debugging);
 366                     pw.print(" crashing="); pw.print(crashing);
 367                     pw.print(" "); pw.print(crashDialog);
 368                     pw.print(" notResponding="); pw.print(notResponding);
 369                     pw.print(" " ); pw.print(anrDialog);
 370                     pw.print(" bad="); pw.print(bad);
 371
 372                     // crashing or notResponding is always set before errorReportReceiver
 373                     if (errorReportReceiver != null) {
 374                         pw.print(" errorReportReceiver=");
 375                         pw.print(errorReportReceiver.flattenToShortString());
 376                     }
 377                     pw.println();
 378         }
 379         if (activities.size() > 0) {
 380             pw.print(prefix); pw.println("Activities:");
 381             for (int i=0; i<activities.size(); i++) {
 382                 pw.print(prefix); pw.print("  - "); pw.println(activities.get(i));
 383             }
 384         }
 385         if (services.size() > 0) {
 386             pw.print(prefix); pw.println("Services:");
 387             for (int i=0; i<services.size(); i++) {
 388                 pw.print(prefix); pw.print("  - "); pw.println(services.valueAt(i));
 389             }
 390         }
 391         if (executingServices.size() > 0) {
 392             pw.print(prefix); pw.print("Executing Services (fg=");
 393             pw.print(execServicesFg); pw.println(")");
 394             for (int i=0; i<executingServices.size(); i++) {
 395                 pw.print(prefix); pw.print("  - "); pw.println(executingServices.valueAt(i));
 396             }
 397         }
 398         if (connections.size() > 0) {
 399             pw.print(prefix); pw.println("Connections:");
 400             for (int i=0; i<connections.size(); i++) {
 401                 pw.print(prefix); pw.print("  - "); pw.println(connections.valueAt(i));
 402             }
 403         }
 404         if (pubProviders.size() > 0) {
 405             pw.print(prefix); pw.println("Published Providers:");
 406             for (int i=0; i<pubProviders.size(); i++) {
 407                 pw.print(prefix); pw.print("  - "); pw.println(pubProviders.keyAt(i));
 408                 pw.print(prefix); pw.print("    -> "); pw.println(pubProviders.valueAt(i));
 409             }
 410         }
 411         if (conProviders.size() > 0) {
 412             pw.print(prefix); pw.println("Connected Providers:");
 413             for (int i=0; i<conProviders.size(); i++) {
 414                 pw.print(prefix); pw.print("  - "); pw.println(conProviders.get(i).toShortString());
 415             }
 416         }
 417         if (curReceiver != null) {
 418             pw.print(prefix); pw.print("curReceiver="); pw.println(curReceiver);
 419         }
 420         if (receivers.size() > 0) {
 421             pw.print(prefix); pw.println("Receivers:");
 422             for (int i=0; i<receivers.size(); i++) {
 423                 pw.print(prefix); pw.print("  - "); pw.println(receivers.valueAt(i));
 424             }
 425         }
 426     }
 427
 428     ProcessRecord(BatteryStatsImpl _batteryStats, ApplicationInfo _info,
 429             String _processName, int _uid) {
 430         mBatteryStats = _batteryStats;
 431         info = _info;
 432         isolated = _info.uid != _uid;
 433         uid = _uid;
 434         userId = UserHandle.getUserId(_uid);
 435         processName = _processName;
 436         pkgList.put(_info.packageName, new ProcessStats.ProcessStateHolder(_info.versionCode));
 437         maxAdj = ProcessList.UNKNOWN_ADJ;
 438         curRawAdj = setRawAdj = ProcessList.INVALID_ADJ;
 439         curAdj = setAdj = ProcessList.INVALID_ADJ;
 440         persistent = false;
 441         removed = false;
 442         lastStateTime = lastPssTime = nextPssTime = SystemClock.uptimeMillis();
 443     }
 444
 445     public void setPid(int _pid) {
 446         pid = _pid;
 447         shortStringName = null;
 448         stringName = null;
 449     }
 450
 451     public void makeActive(IApplicationThread _thread, ProcessStatsService tracker) {
 452         if (thread == null) {
 453             final ProcessState origBase = baseProcessTracker;
 454             if (origBase != null) {
 455                 origBase.setState(ProcessStats.STATE_NOTHING,
 456                         tracker.getMemFactorLocked(), SystemClock.uptimeMillis(), pkgList);
 457                 origBase.makeInactive();
 458             }
 459             baseProcessTracker = tracker.getProcessStateLocked(info.packageName, uid,
 460                     info.versionCode, processName);
 461             baseProcessTracker.makeActive();
 462             for (int i=0; i<pkgList.size(); i++) {
 463                 ProcessStats.ProcessStateHolder holder = pkgList.valueAt(i);
 464                 if (holder.state != null && holder.state != origBase) {
 465                     holder.state.makeInactive();
 466                 }
 467                 holder.state = tracker.getProcessStateLocked(pkgList.keyAt(i), uid,
 468                         info.versionCode, processName);
 469                 if (holder.state != baseProcessTracker) {
 470                     holder.state.makeActive();
 471                 }
 472             }
 473         }
 474         thread = _thread;
 475     }
 476
 477     public void makeInactive(ProcessStatsService tracker) {
 478         thread = null;
 479         final ProcessState origBase = baseProcessTracker;
 480         if (origBase != null) {
 481             if (origBase != null) {
 482                 origBase.setState(ProcessStats.STATE_NOTHING,
 483                         tracker.getMemFactorLocked(), SystemClock.uptimeMillis(), pkgList);
 484                 origBase.makeInactive();
 485             }
 486             baseProcessTracker = null;
 487             for (int i=0; i<pkgList.size(); i++) {
 488                 ProcessStats.ProcessStateHolder holder = pkgList.valueAt(i);
 489                 if (holder.state != null && holder.state != origBase) {
 490                     holder.state.makeInactive();
 491                 }
 492                 holder.state = null;
 493             }
 494         }
 495     }
 496
 497     /**
 498      * This method returns true if any of the activities within the process record are interesting
 499      * to the user. See HistoryRecord.isInterestingToUserLocked()
 500      */
 501     public boolean isInterestingToUserLocked() {
 502         final int size = activities.size();
 503         for (int i = 0 ; i < size ; i++) {
 504             ActivityRecord r = activities.get(i);
 505             if (r.isInterestingToUserLocked()) {
 506                 return true;
 507             }
 508         }
 509         return false;
 510     }
 511
 512     public void stopFreezingAllLocked() {
 513         int i = activities.size();
 514         while (i > 0) {
 515             i--;
 516             activities.get(i).stopFreezingScreenLocked(true);
 517         }
 518     }
 519
 520     public void unlinkDeathRecipient() {
 521         if (deathRecipient != null && thread != null) {
 522             thread.asBinder().unlinkToDeath(deathRecipient, 0);
 523         }
 524         deathRecipient = null;
 525     }
 526
 527     void updateHasAboveClientLocked() {
 528         hasAboveClient = false;
 529         for (int i=connections.size()-1; i>=0; i--) {
 530             ConnectionRecord cr = connections.valueAt(i);
 531             if ((cr.flags&Context.BIND_ABOVE_CLIENT) != 0) {
 532                 hasAboveClient = true;
 533                 break;
 534             }
 535         }
 536     }
 537
 538     int modifyRawOomAdj(int adj) {
 539         if (hasAboveClient) {
 540             // If this process has bound to any services with BIND_ABOVE_CLIENT,
 541             // then we need to drop its adjustment to be lower than the service's
 542             // in order to honor the request.  We want to drop it by one adjustment
 543             // level...  but there is special meaning applied to various levels so
 544             // we will skip some of them.
 545             if (adj < ProcessList.FOREGROUND_APP_ADJ) {
 546                 // System process will not get dropped, ever
 547             } else if (adj < ProcessList.VISIBLE_APP_ADJ) {
 548                 adj = ProcessList.VISIBLE_APP_ADJ;
 549             } else if (adj < ProcessList.PERCEPTIBLE_APP_ADJ) {
 550                 adj = ProcessList.PERCEPTIBLE_APP_ADJ;
 551             } else if (adj < ProcessList.CACHED_APP_MIN_ADJ) {
 552                 adj = ProcessList.CACHED_APP_MIN_ADJ;
 553             } else if (adj < ProcessList.CACHED_APP_MAX_ADJ) {
 554                 adj++;
 555             }
 556         }
 557         return adj;
 558     }
 559
 560     void scheduleCrash(String message) {
 561         // Checking killedbyAm should keep it from showing the crash dialog if the process
 562         // was already dead for a good / normal reason.
 563         if (!killedByAm) {
 564             if (thread != null) {
 565                 if (pid == Process.myPid()) {
 566                     Slog.w(TAG, "scheduleCrash: trying to crash system process!");
 567                     return;
 568                 }
 569                 long ident = Binder.clearCallingIdentity();
 570                 try {
 571                     thread.scheduleCrash(message);
 572                 } catch (RemoteException e) {
 573                     // If it's already dead our work is done. If it's wedged just kill it.
 574                     // We won't get the crash dialog or the error reporting.
 575                     kill("scheduleCrash for '" + message + "' failed", true);
 576                 } finally {
 577                     Binder.restoreCallingIdentity(ident);
 578                 }
 579             }
 580         }
 581     }
 582
 583     void kill(String reason, boolean noisy) {
 584         if (!killedByAm) {
 585             Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "kill");
 586             if (noisy) {
 587                 Slog.i(TAG, "Killing " + toShortString() + " (adj " + setAdj + "): " + reason);
 588             }
 589             EventLog.writeEvent(EventLogTags.AM_KILL, userId, pid, processName, setAdj, reason);
 590             Process.killProcessQuiet(pid);
 591             ActivityManagerService.killProcessGroup(uid, pid);
 592             if (!persistent) {
 593                 killed = true;
 594                 killedByAm = true;
 595             }
 596             Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
 597         }
 598     }
 599
 600     public String toShortString() {
 601         if (shortStringName != null) {
 602             return shortStringName;
 603         }
 604         StringBuilder sb = new StringBuilder(128);
 605         toShortString(sb);
 606         return shortStringName = sb.toString();
 607     }
 608
 609     void toShortString(StringBuilder sb) {
 610         sb.append(pid);
 611         sb.append(':');
 612         sb.append(processName);
 613         sb.append('/');
 614         if (info.uid < Process.FIRST_APPLICATION_UID) {
 615             sb.append(uid);
 616         } else {
 617             sb.append('u');
 618             sb.append(userId);
 619             int appId = UserHandle.getAppId(info.uid);
 620             if (appId >= Process.FIRST_APPLICATION_UID) {
 621                 sb.append('a');
 622                 sb.append(appId - Process.FIRST_APPLICATION_UID);
 623             } else {
 624                 sb.append('s');
 625                 sb.append(appId);
 626             }
 627             if (uid != info.uid) {
 628                 sb.append('i');
 629                 sb.append(UserHandle.getAppId(uid) - Process.FIRST_ISOLATED_UID);
 630             }
 631         }
 632     }
 633
 634     public String toString() {
 635         if (stringName != null) {
 636             return stringName;
 637         }
 638         StringBuilder sb = new StringBuilder(128);
 639         sb.append("ProcessRecord{");
 640         sb.append(Integer.toHexString(System.identityHashCode(this)));
 641         sb.append(' ');
 642         toShortString(sb);
 643         sb.append('}');
 644         return stringName = sb.toString();
 645     }
 646
 647     public String makeAdjReason() {
 648         if (adjSource != null || adjTarget != null) {
 649             StringBuilder sb = new StringBuilder(128);
 650             sb.append(' ');
 651             if (adjTarget instanceof ComponentName) {
 652                 sb.append(((ComponentName)adjTarget).flattenToShortString());
 653             } else if (adjTarget != null) {
 654                 sb.append(adjTarget.toString());
 655             } else {
 656                 sb.append("{null}");
 657             }
 658             sb.append("<=");
 659             if (adjSource instanceof ProcessRecord) {
 660                 sb.append("Proc{");
 661                 sb.append(((ProcessRecord)adjSource).toShortString());
 662                 sb.append("}");
 663             } else if (adjSource != null) {
 664                 sb.append(adjSource.toString());
 665             } else {
 666                 sb.append("{null}");
 667             }
 668             return sb.toString();
 669         }
 670         return null;
 671     }
 672
 673     /*
 674      *  Return true if package has been added false if not
 675      */
 676     public boolean addPackage(String pkg, int versionCode, ProcessStatsService tracker) {
 677         if (!pkgList.containsKey(pkg)) {
 678             ProcessStats.ProcessStateHolder holder = new ProcessStats.ProcessStateHolder(
 679                     versionCode);
 680             if (baseProcessTracker != null) {
 681                 holder.state = tracker.getProcessStateLocked(
 682                         pkg, uid, versionCode, processName);
 683                 pkgList.put(pkg, holder);
 684                 if (holder.state != baseProcessTracker) {
 685                     holder.state.makeActive();
 686                 }
 687             } else {
 688                 pkgList.put(pkg, holder);
 689             }
 690             return true;
 691         }
 692         return false;
 693     }
 694
 695     public int getSetAdjWithServices() {
 696         if (setAdj >= ProcessList.CACHED_APP_MIN_ADJ) {
 697             if (hasStartedServices) {
 698                 return ProcessList.SERVICE_B_ADJ;
 699             }
 700         }
 701         return setAdj;
 702     }
 703
 704     public void forceProcessStateUpTo(int newState) {
 705         if (repProcState > newState) {
 706             curProcState = repProcState = newState;
 707         }
 708     }
 709
 710     /*
 711      *  Delete all packages from list except the package indicated in info
 712      */
 713     public void resetPackageList(ProcessStatsService tracker) {
 714         final int N = pkgList.size();
 715         if (baseProcessTracker != null) {
 716             long now = SystemClock.uptimeMillis();
 717             baseProcessTracker.setState(ProcessStats.STATE_NOTHING,
 718                     tracker.getMemFactorLocked(), now, pkgList);
 719             if (N != 1) {
 720                 for (int i=0; i<N; i++) {
 721                     ProcessStats.ProcessStateHolder holder = pkgList.valueAt(i);
 722                     if (holder.state != null && holder.state != baseProcessTracker) {
 723                         holder.state.makeInactive();
 724                     }
 725
 726                 }
 727                 pkgList.clear();
 728                 ProcessState ps = tracker.getProcessStateLocked(
 729                         info.packageName, uid, info.versionCode, processName);
 730                 ProcessStats.ProcessStateHolder holder = new ProcessStats.ProcessStateHolder(
 731                         info.versionCode);
 732                 holder.state = ps;
 733                 pkgList.put(info.packageName, holder);
 734                 if (ps != baseProcessTracker) {
 735                     ps.makeActive();
 736                 }
 737             }
 738         } else if (N != 1) {
 739             pkgList.clear();
 740             pkgList.put(info.packageName, new ProcessStats.ProcessStateHolder(info.versionCode));
 741         }
 742     }
 743
 744     public String[] getPackageList() {
 745         int size = pkgList.size();
 746         if (size == 0) {
 747             return null;
 748         }
 749         String list[] = new String[size];
 750         for (int i=0; i<pkgList.size(); i++) {
 751             list[i] = pkgList.keyAt(i);
 752         }
 753         return list;
 754     }
 755 }