/**

* Copyright (C) 2006-2008 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 com.android.internal.R;

import com.android.internal.os.BatteryStatsImpl;

import com.android.internal.os.ProcessStats;

import com.android.server.AttributeCache;

import com.android.server.IntentResolver;

import com.android.server.ProcessMap;

import com.android.server.SystemServer;

import com.android.server.Watchdog;

import com.android.server.am.ActivityStack.ActivityState;

import com.android.server.wm.WindowManagerService;

import dalvik.system.Zygote;

import android.app.Activity;

import android.app.ActivityManager;

import android.app.ActivityManagerNative;

import android.app.ActivityThread;

import android.app.AlertDialog;

import android.app.AppGlobals;

import android.app.ApplicationErrorReport;

import android.app.Dialog;

import android.app.IActivityController;

import android.app.IActivityWatcher;

import android.app.IApplicationThread;

import android.app.IInstrumentationWatcher;

import android.app.INotificationManager;

import android.app.IProcessObserver;

import android.app.IServiceConnection;

import android.app.IThumbnailReceiver;

import android.app.Instrumentation;

import android.app.Notification;

import android.app.NotificationManager;

import android.app.PendingIntent;

import android.app.Service;

import android.app.backup.IBackupManager;

import android.content.ActivityNotFoundException;

import android.content.BroadcastReceiver;

import android.content.ComponentCallbacks2;

import android.content.ComponentName;

import android.content.ContentResolver;

import android.content.Context;

import android.content.DialogInterface;

import android.content.Intent;

import android.content.IntentFilter;

import android.content.IIntentReceiver;

import android.content.IIntentSender;

import android.content.IntentSender;

import android.content.pm.ActivityInfo;

import android.content.pm.ApplicationInfo;

import android.content.pm.ConfigurationInfo;

import android.content.pm.IPackageDataObserver;

import android.content.pm.IPackageManager;

import android.content.pm.InstrumentationInfo;

import android.content.pm.PackageInfo;

import android.content.pm.PackageManager;

import android.content.pm.PathPermission;

import android.content.pm.ProviderInfo;

import android.content.pm.ResolveInfo;

import android.content.pm.ServiceInfo;

import android.content.pm.PackageManager.NameNotFoundException;

import android.content.res.CompatibilityInfo;

import android.content.res.Configuration;

import android.graphics.Bitmap;

import android.net.Proxy;

import android.net.ProxyProperties;

import android.net.Uri;

import android.os.Binder;

import android.os.Build;

import android.os.Bundle;

import android.os.Debug;

import android.os.DropBoxManager;

import android.os.Environment;

import android.os.FileObserver;

import android.os.FileUtils;

import android.os.Handler;

import android.os.IBinder;

import android.os.IPermissionController;

import android.os.Looper;

import android.os.Message;

import android.os.Parcel;

import android.os.ParcelFileDescriptor;

import android.os.Process;

import android.os.RemoteCallbackList;

import android.os.RemoteException;

import android.os.ServiceManager;

import android.os.StrictMode;

import android.os.SystemClock;

import android.os.SystemProperties;

import android.provider.Settings;

import android.util.EventLog;

import android.util.Pair;

import android.util.Slog;

import android.util.Log;

import android.util.PrintWriterPrinter;

import android.util.SparseArray;

import android.util.TimeUtils;

import android.view.Gravity;

import android.view.LayoutInflater;

import android.view.View;

import android.view.WindowManager;

import android.view.WindowManagerPolicy;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileDescriptor;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.lang.IllegalStateException;

import java.lang.ref.WeakReference;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.concurrent.atomic.AtomicLong;

//activitymanagernative的一个子类，实现了其中定义的方法，理所当然该类是一个Binder对象，可以实现binder通信

public final class ActivityManagerService extends ActivityManagerNative implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {

static final String TAG = "ActivityManager";

static final boolean DEBUG = false;

static final boolean localLOGV = DEBUG;

static final boolean DEBUG_SWITCH = localLOGV || false;

static final boolean DEBUG_TASKS = localLOGV || false;

static final boolean DEBUG_PAUSE = localLOGV || false;

static final boolean DEBUG_OOM_ADJ = localLOGV || false;

static final boolean DEBUG_TRANSITION = localLOGV || false;

static final boolean DEBUG_BROADCAST = localLOGV || false;

static final boolean DEBUG_BROADCAST_LIGHT = DEBUG_BROADCAST || false;

static final boolean DEBUG_SERVICE = localLOGV || false;

static final boolean DEBUG_SERVICE_EXECUTING = localLOGV || false;

static final boolean DEBUG_VISBILITY = localLOGV || false;

static final boolean DEBUG_PROCESSES = localLOGV || false;

static final boolean DEBUG_PROVIDER = localLOGV || false;

static final boolean DEBUG_URI_PERMISSION = localLOGV || false;

static final boolean DEBUG_USER_LEAVING = localLOGV || false;

static final boolean DEBUG_RESULTS = localLOGV || false;

static final boolean DEBUG_BACKUP = localLOGV || false;

static final boolean DEBUG_CONFIGURATION = localLOGV || false;

static final boolean DEBUG_POWER = localLOGV || false;

static final boolean DEBUG_POWER_QUICK = DEBUG_POWER || false;

static final boolean VALIDATE_TOKENS = false;

static final boolean SHOW_ACTIVITY_START_TIME = true;

// Control over CPU and battery monitoring.

//电池和cpu控制

static final long BATTERY_STATS_TIME = 30*60*1000; // write battery stats every 30 minutes.

static final boolean MONITOR_CPU_USAGE = true;

static final long MONITOR_CPU_MIN_TIME = 5*1000; // don't sample cpu less than every 5 seconds.

static final long MONITOR_CPU_MAX_TIME = 0x0fffffff; // wait possibly forever for next cpu sample.

static final boolean MONITOR_THREAD_CPU_USAGE = false;

// The flags that are set for all calls we make to the package manager.

static final int STOCK_PM_FLAGS = PackageManager.GET_SHARED_LIBRARY_FILES;

//系统配置文件

private static final String SYSTEM_DEBUGGABLE = "ro.debuggable";

//我们能记录的最大任务栈，为20

static final int MAX_RECENT_TASKS = 20;

// Amount of time after a call to stopAppSwitches() during which we will

// prevent further untrusted switches from happening.

static final long APP_SWITCH_DELAY_TIME = 5*1000;

// How long we wait for a launched process to attach to the activity manager

// before we decide it's never going to come up for real.

static final int PROC_START_TIMEOUT = 10*1000;

// How long we wait for a launched process to attach to the activity manager

// before we decide it's never going to come up for real, when the process was

// started with a wrapper for instrumentation (such as Valgrind) because it

// could take much longer than usual.

static final int PROC_START_TIMEOUT_WITH_WRAPPER = 300*1000;

// How long to wait after going idle before forcing apps to GC.

static final int GC_TIMEOUT = 5*1000;

// The minimum amount of time between successive GC requests for a process.

static final int GC_MIN_INTERVAL = 60*1000;

// The rate at which we check for apps using excessive power -- 15 mins.

static final int POWER_CHECK_DELAY = (DEBUG_POWER_QUICK ? 2 : 15) * 60*1000;

// The minimum sample duration we will allow before deciding we have

// enough data on wake locks to start killing things.

static final int WAKE_LOCK_MIN_CHECK_DURATION = (DEBUG_POWER_QUICK ? 1 : 5) * 60*1000;

// The minimum sample duration we will allow before deciding we have

// enough data on CPU usage to start killing things.

static final int CPU_MIN_CHECK_DURATION = (DEBUG_POWER_QUICK ? 1 : 5) * 60*1000;

// How long we allow a receiver to run before giving up on it.

//此处定义抛弃一个广播接收器的时间，为十秒，我找到了这个定义的地方

static final int BROADCAST_TIMEOUT = 10*1000;

// How long we wait for a service to finish executing.

//嗯？？？

static final int SERVICE_TIMEOUT = 20*1000;

// How long a service needs to be running until restarting its process

// is no longer considered to be a relaunch of the service.

static final int SERVICE_RESTART_DURATION = 5*1000;

// How long a service needs to be running until it will start back at

// SERVICE_RESTART_DURATION after being killed.

static final int SERVICE_RESET_RUN_DURATION = 60*1000;

// Multiplying factor to increase restart duration time by, for each time

// a service is killed before it has run for SERVICE_RESET_RUN_DURATION.

static final int SERVICE_RESTART_DURATION_FACTOR = 4;

// The minimum amount of time between restarting services that we allow.

// That is, when multiple services are restarting, we won't allow each

// to restart less than this amount of time from the last one.

static final int SERVICE_MIN_RESTART_TIME_BETWEEN = 10*1000;

// Maximum amount of time for there to be no activity on a service before

// we consider it non-essential and allow its process to go on the

// LRU background list.

static final int MAX_SERVICE_INACTIVITY = 30*60*1000;

// How long we wait until we timeout on key dispatching.

static final int KEY_DISPATCHING_TIMEOUT = 5*1000;

// How long we wait until we timeout on key dispatching during instrumentation.

static final int INSTRUMENTATION_KEY_DISPATCHING_TIMEOUT = 60*1000;

//获取pid

static final int MY_PID = Process.myPid();

static final String[] EMPTY_STRING_ARRAY = new String[0];

//主栈，具体指代什么

public ActivityStack mMainStack;

/***

* Description of a request to start a new activity, which has been held

* due to app switches being disabled.

*/

//开启新activity请求的描述，包含的信息

static class PendingActivityLaunch {

ActivityRecord r;

ActivityRecord sourceRecord;

Uri[] grantedUriPermissions;

int grantedMode;

boolean onlyIfNeeded;

}

final ArrayList<PendingActivityLaunch> mPendingActivityLaunches

= new ArrayList<PendingActivityLaunch>();

/***

* List of all active broadcasts that are to be executed immediately

* (without waiting for another broadcast to finish). Currently this only

* contains broadcasts to registered receivers, to avoid spinning up

* a bunch of processes to execute IntentReceiver components.

*/

//立即执行的广播？？无序广播

final ArrayList<BroadcastRecord> mParallelBroadcasts

= new ArrayList<BroadcastRecord>();

/***

* List of all active broadcasts that are to be executed one at a time.

* The object at the top of the list is the currently activity broadcasts;

* those after it are waiting for the top to finish..

*/

//顺序广播吧

final ArrayList<BroadcastRecord> mOrderedBroadcasts

= new ArrayList<BroadcastRecord>();

/***

* Historical data of past broadcasts, for debugging.

*/

//历史广播，最多保存100个历史记录

static final int MAX_BROADCAST_HISTORY = 100;

final BroadcastRecord[] mBroadcastHistory

= new BroadcastRecord[MAX_BROADCAST_HISTORY];

/***

* Set when we current have a BROADCAST_INTENT_MSG in flight.

*/

boolean mBroadcastsScheduled = false;

/***

* Activity we have told the window manager to have key focus.

*/

ActivityRecord mFocusedActivity = null;

/***

* List of intents that were used to start the most recent tasks.

*/

final ArrayList<TaskRecord> mRecentTasks = new ArrayList<TaskRecord>();

/***

* Process management.

*/

//进程管理？？

final ProcessList mProcessList = new ProcessList();

/***

* All of the applications we currently have running organized by name.

* The keys are strings of the application package name (as

* returned by the package manager), and the keys are ApplicationRecord

* objects.

*/

final ProcessMap<ProcessRecord> mProcessNames = new ProcessMap<ProcessRecord>();

/***

* The currently running heavy-weight process, if any.

*/

ProcessRecord mHeavyWeightProcess = null;

/***

* The last time that various processes have crashed.

*/

final ProcessMap<Long> mProcessCrashTimes = new ProcessMap<Long>();

/***

* Set of applications that we consider to be bad, and will reject

* incoming broadcasts from (which the user has no control over).

* Processes are added to this set when they have crashed twice within

* a minimum amount of time; they are removed from it when they are

* later restarted (hopefully due to some user action). The value is the

* time it was added to the list.

*/

final ProcessMap<Long> mBadProcesses = new ProcessMap<Long>();

/***

* All of the processes we currently have running organized by pid.

* The keys are the pid running the application.

*

* <p>NOTE: This object is protected by its own lock, NOT the global

* activity manager lock!

*/

//sparsearay是android对hashmap的优化版本

final SparseArray<ProcessRecord> mPidsSelfLocked = new SparseArray<ProcessRecord>();

/***

* All of the processes that have been forced to be foreground. The key

* is the pid of the caller who requested it (we hold a death

* link on it).

*/

abstract class ForegroundToken implements IBinder.DeathRecipient {

int pid;

IBinder token;

}

final SparseArray<ForegroundToken> mForegroundProcesses

= new SparseArray<ForegroundToken>();

/***

* List of records for processes that someone had tried to start before the

* system was ready. We don't start them at that point, but ensure they

* are started by the time booting is complete.

*/

final ArrayList<ProcessRecord> mProcessesOnHold

= new ArrayList<ProcessRecord>();

/***

* List of persistent applications that are in the process

* of being started.

*/

final ArrayList<ProcessRecord> mPersistentStartingProcesses

= new ArrayList<ProcessRecord>();

/***

* Processes that are being forcibly torn down.

*/

final ArrayList<ProcessRecord> mRemovedProcesses

= new ArrayList<ProcessRecord>();

/***

* List of running applications, sorted by recent usage.

* The first entry in the list is the least recently used.

* It contains ApplicationRecord objects. This list does NOT include

* any persistent application records (since we never want to exit them).

*/

final ArrayList<ProcessRecord> mLruProcesses

= new ArrayList<ProcessRecord>();

/***

* List of processes that should gc as soon as things are idle.

*/

final ArrayList<ProcessRecord> mProcessesToGc

= new ArrayList<ProcessRecord>();

/***

* This is the process holding what we currently consider to be

* the "home" activity.

*/

//home activity？？

ProcessRecord mHomeProcess;

/***

* Packages that the user has asked to have run in screen size

* compatibility mode instead of filling the screen.

*/

final CompatModePackages mCompatModePackages;

/***

* Set of PendingResultRecord objects that are currently active.

*/

final HashSet mPendingResultRecords = new HashSet();

/***

* Set of IntentSenderRecord objects that are currently active.

*/

final HashMap<PendingIntentRecord.Key, WeakReference<PendingIntentRecord>> mIntentSenderRecords

= new HashMap<PendingIntentRecord.Key, WeakReference<PendingIntentRecord>>();

/***

* Fingerprints (hashCode()) of stack traces that we've

* already logged DropBox entries for. Guarded by itself. If

* something (rogue user app) forces this over

* MAX_DUP_SUPPRESSED_STACKS entries, the contents are cleared.

*/

private final HashSet<Integer> mAlreadyLoggedViolatedStacks = new HashSet<Integer>();

private static final int MAX_DUP_SUPPRESSED_STACKS = 5000;

/***

* Strict Mode background batched logging state.

*

* The string buffer is guarded by itself, and its lock is also

* used to determine if another batched write is already

* in-flight.

*/

private final StringBuilder mStrictModeBuffer = new StringBuilder();

/***

* True if we have a pending unexpired BROADCAST_TIMEOUT_MSG posted to our handler.

*/

private boolean mPendingBroadcastTimeoutMessage;

/***

* Intent broadcast that we have tried to start, but are

* waiting for its application's process to be created. We only

* need one (instead of a list) because we always process broadcasts

* one at a time, so no others can be started while waiting for this

* one.

*/

BroadcastRecord mPendingBroadcast = null;

/***

* The receiver index that is pending, to restart the broadcast if needed.

*/

int mPendingBroadcastRecvIndex;

/***

* Keeps track of all IIntentReceivers that have been registered for

* broadcasts. Hash keys are the receiver IBinder, hash value is

* a ReceiverList.

*/

final HashMap mRegisteredReceivers = new HashMap();

/***

* Resolver for broadcast intents to registered receivers.

* Holds BroadcastFilter (subclass of IntentFilter).

*/

final IntentResolver<BroadcastFilter, BroadcastFilter> mReceiverResolver

= new IntentResolver<BroadcastFilter, BroadcastFilter>() {

@Override

protected boolean allowFilterResult(

BroadcastFilter filter, List<BroadcastFilter> dest) {

IBinder target = filter.receiverList.receiver.asBinder();

for (int i=dest.size()-1; i>=0; i--) {

if (dest.get(i).receiverList.receiver.asBinder() == target) {

return false;

}

}

return true;

}

@Override

protected String packageForFilter(BroadcastFilter filter) {

return filter.packageName;

}

};

/***

* State of all active sticky broadcasts. Keys are the action of the

* sticky Intent, values are an ArrayList of all broadcasted intents with

* that action (which should usually be one).

*/

final HashMap<String, ArrayList<Intent>> mStickyBroadcasts =

new HashMap<String, ArrayList<Intent>>();

/***

* All currently running services.

*/

final HashMap<ComponentName, ServiceRecord> mServices =

new HashMap<ComponentName, ServiceRecord>();

/***

* All currently running services indexed by the Intent used to start them.

*/

final HashMap<Intent.FilterComparison, ServiceRecord> mServicesByIntent =

new HashMap<Intent.FilterComparison, ServiceRecord>();

/***

* All currently bound service connections. Keys are the IBinder of

* the client's IServiceConnection.

*/

final HashMap<IBinder, ArrayList<ConnectionRecord>> mServiceConnections

= new HashMap<IBinder, ArrayList<ConnectionRecord>>();

/***

* 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<ServiceRecord>();

/***

* List of services that are scheduled to restart following a crash.

*/

final ArrayList<ServiceRecord> mRestartingServices

= new ArrayList<ServiceRecord>();

/***

* List of services that are in the process of being stopped.

*/

final ArrayList<ServiceRecord> mStoppingServices

= new ArrayList<ServiceRecord>();

/***

* Backup/restore process management

*/

String mBackupAppName = null;

BackupRecord mBackupTarget = null;

/***

* List of PendingThumbnailsRecord objects of clients who are still

* waiting to receive all of the thumbnails for a task.

*/

final ArrayList mPendingThumbnails = new ArrayList();

/***

* List of HistoryRecord objects that have been finished and must

* still report back to a pending thumbnail receiver.

*/

final ArrayList mCancelledThumbnails = new ArrayList();

/***

* All of the currently running global content providers. Keys are a

* string containing the provider name and values are a

* ContentProviderRecord object containing the data about it. Note

* that a single provider may be published under multiple names, so

* there may be multiple entries here for a single one in mProvidersByClass.

*/

//运行中的全局的name---->contentprovider映射

final HashMap<String, ContentProviderRecord> mProvidersByName

= new HashMap<String, ContentProviderRecord>();

/***

* All of the currently running global content providers. Keys are a

* string containing the provider's implementation class and values are a

* ContentProviderRecord object containing the data about it.

*/

//同上 class(实现contentprovider的类名)---->cotentprovider

final HashMap<ComponentName, ContentProviderRecord> mProvidersByClass

= new HashMap<ComponentName, ContentProviderRecord>();

/***

* List of content providers who have clients waiting for them. The

* application is currently being launched and the provider will be

* removed from this list once it is published.

*/

//contentprovider列表

final ArrayList<ContentProviderRecord> mLaunchingProviders

= new ArrayList<ContentProviderRecord>();

/***

* Global set of specific Uri permissions that have been granted.

*/

final private SparseArray<HashMap<Uri, UriPermission>> mGrantedUriPermissions

= new SparseArray<HashMap<Uri, UriPermission>>();

CoreSettingsObserver mCoreSettingsObserver;

/***

* Thread-local storage used to carry caller permissions over through

* indirect content-provider access.

* @see #ActivityManagerService.openContentUri()

*/

private class Identity {

public int pid;

public int uid;

Identity(int _pid, int _uid) {

pid = _pid;

uid = _uid;

}

}

private static ThreadLocal<Identity> sCallerIdentity = new ThreadLocal<Identity>();

/***

* All information we have collected about the runtime performance of

* any user id that can impact battery performance.

*/

//用到了电池状态服务

final BatteryStatsService mBatteryStatsService;

/***

* information about component usage

*/

final UsageStatsService mUsageStatsService;

/***

* Current configuration information. HistoryRecord objects are given

* a reference to this object to indicate which configuration they are

* currently running in, so this object must be kept immutable.

*/

Configuration mConfiguration = new Configuration();

/***

* Current sequencing integer of the configuration, for skipping old

* configurations.

*/

int mConfigurationSeq = 0;

/***

* Hardware-reported OpenGLES version.

*/

final int GL_ES_VERSION;

/***

* List of initialization arguments to pass to all processes when binding applications to them.

* For example, references to the commonly used services.

*/

HashMap<String, IBinder> mAppBindArgs;

/***

* Temporary to avoid allocations. Protected by main lock.

*/

final StringBuilder mStringBuilder = new StringBuilder(256);

/***

* Used to control how we initialize the service.

*/

//用来控制如何初始化一个服务

boolean mStartRunning = false;

ComponentName mTopComponent;

String mTopAction;

String mTopData;

boolean mProcessesReady = false;

boolean mSystemReady = false;

boolean mBooting = false;

boolean mWaitingUpdate = false;

boolean mDidUpdate = false;

boolean mOnBattery = false;

boolean mLaunchWarningShown = false;

Context mContext;

int mFactoryTest;

boolean mCheckedForSetup;

/***

* The time at which we will allow normal application switches again,

* after a call to {@link #stopAppSwitches()}.

*/

long mAppSwitchesAllowedTime;

/***

* This is set to true after the first switch after mAppSwitchesAllowedTime

* is set; any switches after that will clear the time.

*/

boolean mDidAppSwitch;

/***

* Last time (in realtime) at which we checked for power usage.

*/

long mLastPowerCheckRealtime;

/***

* Last time (in uptime) at which we checked for power usage.

*/

long mLastPowerCheckUptime;

/***

* Set while we are wanting to sleep, to prevent any

* activities from being started/resumed.

*/

boolean mSleeping = false;

/***

* Set if we are shutting down the system, similar to sleeping.

*/

boolean mShuttingDown = false;

/***

* Task identifier that activities are currently being started

* in. Incremented each time a new task is created.

* todo: Replace this with a TokenSpace class that generates non-repeating

* integers that won't wrap.

*/

int mCurTask = 1;

/***

* Current sequence id for oom_adj computation traversal.

*/

int mAdjSeq = 0;

/***

* Current sequence id for process LRU updating.

*/

int mLruSeq = 0;

/***

* System monitoring: number of processes that died since the last

* N procs were started.

*/

int[] mProcDeaths = new int[20];

/***

* This is set if we had to do a delayed dexopt of an app before launching

* it, to increasing the ANR timeouts in that case.

*/

boolean mDidDexOpt;

String mDebugApp = null;

boolean mWaitForDebugger = false;

boolean mDebugTransient = false;

String mOrigDebugApp = null;

boolean mOrigWaitForDebugger = false;

boolean mAlwaysFinishActivities = false;

IActivityController mController = null;

String mProfileApp = null;

ProcessRecord mProfileProc = null;

String mProfileFile;

ParcelFileDescriptor mProfileFd;

int mProfileType = 0;

boolean mAutoStopProfiler = false;

final RemoteCallbackList<IActivityWatcher> mWatchers

= new RemoteCallbackList<IActivityWatcher>();

final RemoteCallbackList<IProcessObserver> mProcessObservers

= new RemoteCallbackList<IProcessObserver>();

/***

* Callback of last caller to {@link #requestPss}.

*/

Runnable mRequestPssCallback;

/***

* Remaining processes for which we are waiting results from the last

* call to {@link #requestPss}.

*/

final ArrayList<ProcessRecord> mRequestPssList

= new ArrayList<ProcessRecord>();

/***

* Runtime statistics collection thread. This object's lock is used to

* protect all related state.

*/

final Thread mProcessStatsThread;

/***

* Used to collect process stats when showing not responding dialog.

* Protected by mProcessStatsThread.

*/

final ProcessStats mProcessStats = new ProcessStats(

MONITOR_THREAD_CPU_USAGE);

final AtomicLong mLastCpuTime = new AtomicLong(0);

final AtomicBoolean mProcessStatsMutexFree = new AtomicBoolean(true);

long mLastWriteTime = 0;

/***

* Set to true after the system has finished booting.

*/

//标识系统是否启动完毕

boolean mBooted = false;

int mProcessLimit = ProcessList.MAX_HIDDEN_APPS;

int mProcessLimitOverride = -1;

//居然还用到窗口管理服务

WindowManagerService mWindowManager;

//自己用自己？？

static ActivityManagerService mSelf;

//activity thread，应该是该类负责实例化activitythread

static ActivityThread mSystemThread;

private final class AppDeathRecipient implements IBinder.DeathRecipient {

final ProcessRecord mApp;

final int mPid;

final IApplicationThread mAppThread;

AppDeathRecipient(ProcessRecord app, int pid,

IApplicationThread thread) {

if (localLOGV) Slog.v(

TAG, "New death recipient " + this

+ " for thread " + thread.asBinder());

mApp = app;

mPid = pid;

mAppThread = thread;

}

public void binderDied() {

if (localLOGV) Slog.v(

TAG, "Death received in " + this

+ " for thread " + mAppThread.asBinder());

synchronized(ActivityManagerService.this) {

appDiedLocked(mApp, mPid, mAppThread);

}

}

}

//定义一系列消息

static final int SHOW_ERROR_MSG = 1;

static final int SHOW_NOT_RESPONDING_MSG = 2;

static final int SHOW_FACTORY_ERROR_MSG = 3;

static final int UPDATE_CONFIGURATION_MSG = 4;

static final int GC_BACKGROUND_PROCESSES_MSG = 5;

static final int WAIT_FOR_DEBUGGER_MSG = 6;

static final int BROADCAST_INTENT_MSG = 7;

static final int BROADCAST_TIMEOUT_MSG = 8;

static final int SERVICE_TIMEOUT_MSG = 12;

static final int UPDATE_TIME_ZONE = 13;

static final int SHOW_UID_ERROR_MSG = 14;

static final int IM_FEELING_LUCKY_MSG = 15;

static final int PROC_START_TIMEOUT_MSG = 20;

static final int DO_PENDING_ACTIVITY_LAUNCHES_MSG = 21;

static final int KILL_APPLICATION_MSG = 22;

static final int FINALIZE_PENDING_INTENT_MSG = 23;

static final int POST_HEAVY_NOTIFICATION_MSG = 24;

static final int CANCEL_HEAVY_NOTIFICATION_MSG = 25;

static final int SHOW_STRICT_MODE_VIOLATION_MSG = 26;

static final int CHECK_EXCESSIVE_WAKE_LOCKS_MSG = 27;

static final int CLEAR_DNS_CACHE = 28;

static final int UPDATE_HTTP_PROXY = 29;

static final int SHOW_COMPAT_MODE_DIALOG_MSG = 30;

static final int DISPATCH_FOREGROUND_ACTIVITIES_CHANGED = 31;

static final int DISPATCH_PROCESS_DIED = 32;

static final int REPORT_MEM_USAGE = 33;

//这个做什么用

AlertDialog mUidAlert;

CompatModeDialog mCompatModeDialog;

long mLastMemUsageReportTime = 0;

//定义一个handler进行消息的处理，消息定义如上

final Handler mHandler = new Handler() {

//public Handler() {

// if (localLOGV) Slog.v(TAG, "Handler started!");

//}

public void handleMessage(Message msg) {

switch (msg.what) {

case SHOW_ERROR_MSG: {

HashMap data = (HashMap) msg.obj;

synchronized (ActivityManagerService.this) {

ProcessRecord proc = (ProcessRecord)data.get("app");

if (proc != null && proc.crashDialog != null) {

Slog.e(TAG, "App already has crash dialog: " + proc);

return;

}

AppErrorResult res = (AppErrorResult) data.get("result");

if (!mSleeping && !mShuttingDown) {

Dialog d = new AppErrorDialog(mContext, res, proc);

d.show();

proc.crashDialog = d;

} else {

// The device is asleep, so just pretend that the user

// saw a crash dialog and hit "force quit".

res.set(0);

}

}

ensureBootCompleted();

} break;

case SHOW_NOT_RESPONDING_MSG: {

synchronized (ActivityManagerService.this) {

HashMap data = (HashMap) msg.obj;

ProcessRecord proc = (ProcessRecord)data.get("app");

if (proc != null && proc.anrDialog != null) {

Slog.e(TAG, "App already has anr dialog: " + proc);

return;

}

//会发送一个未响应的广播

Intent intent = new Intent("android.intent.action.ANR");

if (!mProcessesReady) {

intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);

}

//发送

broadcastIntentLocked(null, null, intent,

null, null, 0, null, null, null,

false, false, MY_PID, Process.SYSTEM_UID);

//弹出对话框

Dialog d = new AppNotRespondingDialog(ActivityManagerService.this,

mContext, proc, (ActivityRecord)data.get("activity"));

d.show();

proc.anrDialog = d;

}

ensureBootCompleted();

} break;

case SHOW_STRICT_MODE_VIOLATION_MSG: {

HashMap<String, Object> data = (HashMap<String, Object>) msg.obj;

synchronized (ActivityManagerService.this) {

ProcessRecord proc = (ProcessRecord) data.get("app");

if (proc == null) {

Slog.e(TAG, "App not found when showing strict mode dialog.");

break;

}

if (proc.crashDialog != null) {

Slog.e(TAG, "App already has strict mode dialog: " + proc);

return;

}

AppErrorResult res = (AppErrorResult) data.get("result");

if (!mSleeping && !mShuttingDown) {

Dialog d = new StrictModeViolationDialog(mContext, res, proc);

d.show();

proc.crashDialog = d;

} else {

// The device is asleep, so just pretend that the user

// saw a crash dialog and hit "force quit".

res.set(0);

}

}

ensureBootCompleted();

} break;

case SHOW_FACTORY_ERROR_MSG: {

Dialog d = new FactoryErrorDialog(

mContext, msg.getData().getCharSequence("msg"));

d.show();

ensureBootCompleted();

} break;

case UPDATE_CONFIGURATION_MSG: {

final ContentResolver resolver = mContext.getContentResolver();

Settings.System.putConfiguration(resolver, (Configuration)msg.obj);

} break;

case GC_BACKGROUND_PROCESSES_MSG: {

synchronized (ActivityManagerService.this) {

performAppGcsIfAppropriateLocked();

}

} break;

case WAIT_FOR_DEBUGGER_MSG: {

synchronized (ActivityManagerService.this) {

ProcessRecord app = (ProcessRecord)msg.obj;

if (msg.arg1 != 0) {

if (!app.waitedForDebugger) {

Dialog d = new AppWaitingForDebuggerDialog(

ActivityManagerService.this,

mContext, app);

app.waitDialog = d;

app.waitedForDebugger = true;

d.show();

}

} else {

if (app.waitDialog != null) {

app.waitDialog.dismiss();

app.waitDialog = null;

}

}

}

} break;

case BROADCAST_INTENT_MSG: {

if (DEBUG_BROADCAST) Slog.v(

TAG, "Received BROADCAST_INTENT_MSG");

processNextBroadcast(true);

} break;

case BROADCAST_TIMEOUT_MSG: {

synchronized (ActivityManagerService.this) {

broadcastTimeoutLocked(true);

}

} break;

case SERVICE_TIMEOUT_MSG: {

if (mDidDexOpt) {

mDidDexOpt = false;

Message nmsg = mHandler.obtainMessage(SERVICE_TIMEOUT_MSG);