1/*
2 * Copyright (C) 2006-2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.server.am;
18
19import com.android.internal.telephony.TelephonyIntents;
20import com.google.android.collect.Lists;
21import com.google.android.collect.Maps;
22import com.android.internal.R;
23import com.android.internal.annotations.GuardedBy;
24import com.android.internal.app.AssistUtils;
25import com.android.internal.app.DumpHeapActivity;
26import com.android.internal.app.IAppOpsCallback;
27import com.android.internal.app.IAppOpsService;
28import com.android.internal.app.IVoiceInteractor;
29import com.android.internal.app.ProcessMap;
30import com.android.internal.app.SystemUserHomeActivity;
31import com.android.internal.app.procstats.ProcessStats;
32import com.android.internal.os.BackgroundThread;
33import com.android.internal.os.BatteryStatsImpl;
34import com.android.internal.os.IResultReceiver;
35import com.android.internal.os.ProcessCpuTracker;
36import com.android.internal.os.TransferPipe;
37import com.android.internal.os.Zygote;
38import com.android.internal.os.InstallerConnection.InstallerException;
39import com.android.internal.util.ArrayUtils;
40import com.android.internal.util.FastPrintWriter;
41import com.android.internal.util.FastXmlSerializer;
42import com.android.internal.util.MemInfoReader;
43import com.android.internal.util.Preconditions;
44import com.android.server.AppOpsService;
45import com.android.server.AttributeCache;
46import com.android.server.DeviceIdleController;
47import com.android.server.IntentResolver;
48import com.android.server.LocalServices;
49import com.android.server.LockGuard;
50import com.android.server.ServiceThread;
51import com.android.server.SystemService;
52import com.android.server.SystemServiceManager;
53import com.android.server.Watchdog;
54import com.android.server.am.ActivityStack.ActivityState;
55import com.android.server.firewall.IntentFirewall;
56import com.android.server.pm.Installer;
57import com.android.server.statusbar.StatusBarManagerInternal;
58import com.android.server.vr.VrManagerInternal;
59import com.android.server.wm.WindowManagerService;
60
61import org.xmlpull.v1.XmlPullParser;
62import org.xmlpull.v1.XmlPullParserException;
63import org.xmlpull.v1.XmlSerializer;
64
65import android.Manifest;
66import android.Manifest.permission;
67import android.annotation.NonNull;
68import android.annotation.UserIdInt;
69import android.app.Activity;
70import android.app.ActivityManager;
71import android.app.ActivityManager.RunningTaskInfo;
72import android.app.ActivityManager.StackId;
73import android.app.ActivityManager.StackInfo;
74import android.app.ActivityManager.TaskThumbnailInfo;
75import android.app.ActivityManagerInternal;
76import android.app.ActivityManagerInternal.SleepToken;
77import android.app.ActivityManagerNative;
78import android.app.ActivityOptions;
79import android.app.ActivityThread;
80import android.app.AlertDialog;
81import android.app.AppGlobals;
82import android.app.AppOpsManager;
83import android.app.ApplicationErrorReport;
84import android.app.ApplicationThreadNative;
85import android.app.BroadcastOptions;
86import android.app.Dialog;
87import android.app.IActivityContainer;
88import android.app.IActivityContainerCallback;
89import android.app.IActivityController;
90import android.app.IAppTask;
91import android.app.IApplicationThread;
92import android.app.IInstrumentationWatcher;
93import android.app.INotificationManager;
94import android.app.IProcessObserver;
95import android.app.IServiceConnection;
96import android.app.IStopUserCallback;
97import android.app.ITaskStackListener;
98import android.app.IUiAutomationConnection;
99import android.app.IUidObserver;
100import android.app.IUserSwitchObserver;
101import android.app.Instrumentation;
102import android.app.Notification;
103import android.app.NotificationManager;
104import android.app.PendingIntent;
105import android.app.ProfilerInfo;
106import android.app.admin.DevicePolicyManager;
107import android.app.assist.AssistContent;
108import android.app.assist.AssistStructure;
109import android.app.backup.IBackupManager;
110import android.app.usage.UsageEvents;
111import android.app.usage.UsageStatsManagerInternal;
112import android.appwidget.AppWidgetManager;
113import android.content.ActivityNotFoundException;
114import android.content.BroadcastReceiver;
115import android.content.ClipData;
116import android.content.ComponentCallbacks2;
117import android.content.ComponentName;
118import android.content.ContentProvider;
119import android.content.ContentResolver;
120import android.content.Context;
121import android.content.DialogInterface;
122import android.content.IContentProvider;
123import android.content.IIntentReceiver;
124import android.content.IIntentSender;
125import android.content.Intent;
126import android.content.IntentFilter;
127import android.content.IntentSender;
128import android.content.pm.ActivityInfo;
129import android.content.pm.ApplicationInfo;
130import android.content.pm.ConfigurationInfo;
131import android.content.pm.IPackageDataObserver;
132import android.content.pm.IPackageManager;
133import android.content.pm.InstrumentationInfo;
134import android.content.pm.PackageInfo;
135import android.content.pm.PackageManager;
136import android.content.pm.PackageManager.NameNotFoundException;
137import android.content.pm.PackageManagerInternal;
138import android.content.pm.ParceledListSlice;
139import android.content.pm.PathPermission;
140import android.content.pm.PermissionInfo;
141import android.content.pm.ProviderInfo;
142import android.content.pm.ResolveInfo;
143import android.content.pm.ServiceInfo;
144import android.content.pm.UserInfo;
145import android.content.res.CompatibilityInfo;
146import android.content.res.Configuration;
147import android.content.res.Resources;
148import android.database.ContentObserver;
149import android.graphics.Bitmap;
150import android.graphics.Point;
151import android.graphics.Rect;
152import android.location.LocationManager;
153import android.net.Proxy;
154import android.net.ProxyInfo;
155import android.net.Uri;
156import android.os.BatteryStats;
157import android.os.Binder;
158import android.os.Build;
159import android.os.Bundle;
160import android.os.Debug;
161import android.os.DropBoxManager;
162import android.os.Environment;
163import android.os.FactoryTest;
164import android.os.FileObserver;
165import android.os.FileUtils;
166import android.os.Handler;
167import android.os.IBinder;
168import android.os.IPermissionController;
169import android.os.IProcessInfoService;
170import android.os.IProgressListener;
171import android.os.LocaleList;
172import android.os.Looper;
173import android.os.Message;
174import android.os.Parcel;
175import android.os.ParcelFileDescriptor;
176import android.os.PersistableBundle;
177import android.os.PowerManager;
178import android.os.PowerManagerInternal;
179import android.os.Process;
180import android.os.RemoteCallbackList;
181import android.os.RemoteException;
182import android.os.ResultReceiver;
183import android.os.ServiceManager;
184import android.os.StrictMode;
185import android.os.SystemClock;
186import android.os.SystemProperties;
187import android.os.Trace;
188import android.os.TransactionTooLargeException;
189import android.os.UpdateLock;
190import android.os.UserHandle;
191import android.os.UserManager;
192import android.os.WorkSource;
193import android.os.storage.IMountService;
194import android.os.storage.MountServiceInternal;
195import android.os.storage.StorageManager;
196import android.provider.Settings;
197import android.service.voice.IVoiceInteractionSession;
198import android.service.voice.VoiceInteractionManagerInternal;
199import android.service.voice.VoiceInteractionSession;
200import android.telecom.TelecomManager;
201import android.text.format.DateUtils;
202import android.text.format.Time;
203import android.text.style.SuggestionSpan;
204import android.util.ArrayMap;
205import android.util.ArraySet;
206import android.util.AtomicFile;
207import android.util.DebugUtils;
208import android.util.DisplayMetrics;
209import android.util.EventLog;
210import android.util.Log;
211import android.util.Pair;
212import android.util.PrintWriterPrinter;
213import android.util.Slog;
214import android.util.SparseArray;
215import android.util.TimeUtils;
216import android.util.Xml;
217import android.view.Display;
218import android.view.Gravity;
219import android.view.LayoutInflater;
220import android.view.View;
221import android.view.WindowManager;
222
223import java.io.File;
224import java.io.FileDescriptor;
225import java.io.FileInputStream;
226import java.io.FileNotFoundException;
227import java.io.FileOutputStream;
228import java.io.IOException;
229import java.io.InputStreamReader;
230import java.io.PrintWriter;
231import java.io.StringWriter;
232import java.lang.ref.WeakReference;
233import java.nio.charset.StandardCharsets;
234import java.util.ArrayList;
235import java.util.Arrays;
236import java.util.Collections;
237import java.util.Comparator;
238import java.util.HashMap;
239import java.util.HashSet;
240import java.util.Iterator;
241import java.util.List;
242import java.util.Locale;
243import java.util.Map;
244import java.util.Objects;
245import java.util.Set;
246import java.util.concurrent.atomic.AtomicBoolean;
247import java.util.concurrent.atomic.AtomicLong;
248
249import dalvik.system.VMRuntime;
250
251import libcore.io.IoUtils;
252import libcore.util.EmptyArray;
253
254import static android.Manifest.permission.INTERACT_ACROSS_USERS;
255import static android.Manifest.permission.INTERACT_ACROSS_USERS_FULL;
256import static android.Manifest.permission.MANAGE_ACTIVITY_STACKS;
257import static android.Manifest.permission.START_TASKS_FROM_RECENTS;
258import static android.app.ActivityManager.DOCKED_STACK_CREATE_MODE_TOP_OR_LEFT;
259import static android.app.ActivityManager.RESIZE_MODE_PRESERVE_WINDOW;
260import static android.app.ActivityManager.StackId.DOCKED_STACK_ID;
261import static android.app.ActivityManager.StackId.FREEFORM_WORKSPACE_STACK_ID;
262import static android.app.ActivityManager.StackId.FULLSCREEN_WORKSPACE_STACK_ID;
263import static android.app.ActivityManager.StackId.HOME_STACK_ID;
264import static android.app.ActivityManager.StackId.INVALID_STACK_ID;
265import static android.app.ActivityManager.StackId.PINNED_STACK_ID;
266import static android.content.pm.PackageManager.FEATURE_FREEFORM_WINDOW_MANAGEMENT;
267import static android.content.pm.PackageManager.FEATURE_LEANBACK_ONLY;
268import static android.content.pm.PackageManager.FEATURE_PICTURE_IN_PICTURE;
269import static android.content.pm.PackageManager.GET_PROVIDERS;
270import static android.content.pm.PackageManager.MATCH_DEBUG_TRIAGED_MISSING;
271import static android.content.pm.PackageManager.MATCH_DIRECT_BOOT_AWARE;
272import static android.content.pm.PackageManager.MATCH_DIRECT_BOOT_UNAWARE;
273import static android.content.pm.PackageManager.MATCH_SYSTEM_ONLY;
274import static android.content.pm.PackageManager.MATCH_UNINSTALLED_PACKAGES;
275import static android.content.pm.PackageManager.PERMISSION_GRANTED;
276import static android.content.res.Configuration.UI_MODE_TYPE_TELEVISION;
277import static android.os.Process.PROC_CHAR;
278import static android.os.Process.PROC_OUT_LONG;
279import static android.os.Process.PROC_PARENS;
280import static android.os.Process.PROC_SPACE_TERM;
281import static android.provider.Settings.Global.ALWAYS_FINISH_ACTIVITIES;
282import static android.provider.Settings.Global.DEBUG_APP;
283import static android.provider.Settings.Global.DEVELOPMENT_ENABLE_FREEFORM_WINDOWS_SUPPORT;
284import static android.provider.Settings.Global.DEVELOPMENT_FORCE_RESIZABLE_ACTIVITIES;
285import static android.provider.Settings.Global.DEVELOPMENT_FORCE_RTL;
286import static android.provider.Settings.Global.LENIENT_BACKGROUND_CHECK;
287import static android.provider.Settings.Global.WAIT_FOR_DEBUGGER;
288import static android.provider.Settings.System.FONT_SCALE;
289import static com.android.internal.util.XmlUtils.readBooleanAttribute;
290import static com.android.internal.util.XmlUtils.readIntAttribute;
291import static com.android.internal.util.XmlUtils.readLongAttribute;
292import static com.android.internal.util.XmlUtils.writeBooleanAttribute;
293import static com.android.internal.util.XmlUtils.writeIntAttribute;
294import static com.android.internal.util.XmlUtils.writeLongAttribute;
295import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_ALL;
296import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_ANR;
297import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_BACKUP;
298import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_BROADCAST;
299import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_BROADCAST_BACKGROUND;
300import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_BROADCAST_LIGHT;
301import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_CLEANUP;
302import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_CONFIGURATION;
303import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_FOCUS;
304import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_IMMERSIVE;
305import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_LOCKSCREEN;
306import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_LOCKTASK;
307import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_LRU;
308import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_MU;
309import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_OOM_ADJ;
310import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_PERMISSIONS_REVIEW;
311import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_POWER;
312import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_POWER_QUICK;
313import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_PROCESSES;
314import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_PROCESS_OBSERVERS;
315import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_PROVIDER;
316import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_PSS;
317import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_RECENTS;
318import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_SERVICE;
319import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_STACK;
320import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_SWITCH;
321import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_TASKS;
322import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_UID_OBSERVERS;
323import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_URI_PERMISSION;
324import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_USAGE_STATS;
325import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_VISIBILITY;
326import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_VISIBLE_BEHIND;
327import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_WHITELISTS;
328import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_BACKUP;
329import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_BROADCAST;
330import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_CLEANUP;
331import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_CONFIGURATION;
332import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_FOCUS;
333import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_IMMERSIVE;
334import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_LOCKSCREEN;
335import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_LOCKTASK;
336import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_LRU;
337import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_MU;
338import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_OOM_ADJ;
339import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_POWER;
340import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_PROCESSES;
341import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_PROCESS_OBSERVERS;
342import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_PROVIDER;
343import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_PSS;
344import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_RECENTS;
345import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_SERVICE;
346import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_STACK;
347import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_SWITCH;
348import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_UID_OBSERVERS;
349import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_URI_PERMISSION;
350import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_VISIBILITY;
351import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_VISIBLE_BEHIND;
352import static com.android.server.am.ActivityManagerDebugConfig.TAG_AM;
353import static com.android.server.am.ActivityManagerDebugConfig.TAG_WITH_CLASS_NAME;
354import static com.android.server.am.ActivityRecord.RECENTS_ACTIVITY_TYPE;
355import static com.android.server.am.ActivityStackSupervisor.ActivityContainer.FORCE_NEW_TASK_FLAGS;
356import static com.android.server.am.ActivityStackSupervisor.DEFER_RESUME;
357import static com.android.server.am.ActivityStackSupervisor.FORCE_FOCUS;
358import static com.android.server.am.ActivityStackSupervisor.ON_TOP;
359import static com.android.server.am.ActivityStackSupervisor.PRESERVE_WINDOWS;
360import static com.android.server.am.ActivityStackSupervisor.RESTORE_FROM_RECENTS;
361import static com.android.server.am.TaskRecord.INVALID_TASK_ID;
362import static com.android.server.am.TaskRecord.LOCK_TASK_AUTH_DONT_LOCK;
363import static com.android.server.am.TaskRecord.LOCK_TASK_AUTH_LAUNCHABLE_PRIV;
364import static com.android.server.am.TaskRecord.LOCK_TASK_AUTH_PINNABLE;
365import static com.android.server.wm.AppTransition.TRANSIT_ACTIVITY_OPEN;
366import static com.android.server.wm.AppTransition.TRANSIT_ACTIVITY_RELAUNCH;
367import static com.android.server.wm.AppTransition.TRANSIT_TASK_IN_PLACE;
368import static com.android.server.wm.AppTransition.TRANSIT_TASK_OPEN;
369import static com.android.server.wm.AppTransition.TRANSIT_TASK_TO_FRONT;
370import static org.xmlpull.v1.XmlPullParser.END_DOCUMENT;
371import static org.xmlpull.v1.XmlPullParser.START_TAG;
372
373public final class ActivityManagerService extends ActivityManagerNative
374        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
375
376    private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityManagerService" : TAG_AM;
377    private static final String TAG_BACKUP = TAG + POSTFIX_BACKUP;
378    private static final String TAG_BROADCAST = TAG + POSTFIX_BROADCAST;
379    private static final String TAG_CLEANUP = TAG + POSTFIX_CLEANUP;
380    private static final String TAG_CONFIGURATION = TAG + POSTFIX_CONFIGURATION;
381    private static final String TAG_FOCUS = TAG + POSTFIX_FOCUS;
382    private static final String TAG_IMMERSIVE = TAG + POSTFIX_IMMERSIVE;
383    private static final String TAG_LOCKSCREEN = TAG + POSTFIX_LOCKSCREEN;
384    private static final String TAG_LOCKTASK = TAG + POSTFIX_LOCKTASK;
385    private static final String TAG_LRU = TAG + POSTFIX_LRU;
386    private static final String TAG_MU = TAG + POSTFIX_MU;
387    private static final String TAG_OOM_ADJ = TAG + POSTFIX_OOM_ADJ;
388    private static final String TAG_POWER = TAG + POSTFIX_POWER;
389    private static final String TAG_PROCESS_OBSERVERS = TAG + POSTFIX_PROCESS_OBSERVERS;
390    private static final String TAG_PROCESSES = TAG + POSTFIX_PROCESSES;
391    private static final String TAG_PROVIDER = TAG + POSTFIX_PROVIDER;
392    private static final String TAG_PSS = TAG + POSTFIX_PSS;
393    private static final String TAG_RECENTS = TAG + POSTFIX_RECENTS;
394    private static final String TAG_SERVICE = TAG + POSTFIX_SERVICE;
395    private static final String TAG_STACK = TAG + POSTFIX_STACK;
396    private static final String TAG_SWITCH = TAG + POSTFIX_SWITCH;
397    private static final String TAG_UID_OBSERVERS = TAG + POSTFIX_UID_OBSERVERS;
398    private static final String TAG_URI_PERMISSION = TAG + POSTFIX_URI_PERMISSION;
399    private static final String TAG_VISIBILITY = TAG + POSTFIX_VISIBILITY;
400    private static final String TAG_VISIBLE_BEHIND = TAG + POSTFIX_VISIBLE_BEHIND;
401
402    // Mock "pretend we're idle now" broadcast action to the job scheduler; declared
403    // here so that while the job scheduler can depend on AMS, the other way around
404    // need not be the case.
405    public static final String ACTION_TRIGGER_IDLE = "com.android.server.ACTION_TRIGGER_IDLE";
406
407    /** Control over CPU and battery monitoring */
408    // write battery stats every 30 minutes.
409    static final long BATTERY_STATS_TIME = 30 * 60 * 1000;
410    static final boolean MONITOR_CPU_USAGE = true;
411    // don't sample cpu less than every 5 seconds.
412    static final long MONITOR_CPU_MIN_TIME = 5 * 1000;
413    // wait possibly forever for next cpu sample.
414    static final long MONITOR_CPU_MAX_TIME = 0x0fffffff;
415    static final boolean MONITOR_THREAD_CPU_USAGE = false;
416
417    // The flags that are set for all calls we make to the package manager.
418    static final int STOCK_PM_FLAGS = PackageManager.GET_SHARED_LIBRARY_FILES;
419
420    static final String SYSTEM_DEBUGGABLE = "ro.debuggable";
421
422    static final boolean IS_USER_BUILD = "user".equals(Build.TYPE);
423
424    // Amount of time after a call to stopAppSwitches() during which we will
425    // prevent further untrusted switches from happening.
426    static final long APP_SWITCH_DELAY_TIME = 5*1000;
427
428    // How long we wait for a launched process to attach to the activity manager
429    // before we decide it's never going to come up for real.
430    static final int PROC_START_TIMEOUT = 10*1000;
431    // How long we wait for an attached process to publish its content providers
432    // before we decide it must be hung.
433    static final int CONTENT_PROVIDER_PUBLISH_TIMEOUT = 10*1000;
434
435    // How long we will retain processes hosting content providers in the "last activity"
436    // state before allowing them to drop down to the regular cached LRU list.  This is
437    // to avoid thrashing of provider processes under low memory situations.
438    static final int CONTENT_PROVIDER_RETAIN_TIME = 20*1000;
439
440    // How long we wait for a launched process to attach to the activity manager
441    // before we decide it's never going to come up for real, when the process was
442    // started with a wrapper for instrumentation (such as Valgrind) because it
443    // could take much longer than usual.
444    static final int PROC_START_TIMEOUT_WITH_WRAPPER = 1200*1000;
445
446    // How long to wait after going idle before forcing apps to GC.
447    static final int GC_TIMEOUT = 5*1000;
448
449    // The minimum amount of time between successive GC requests for a process.
450    static final int GC_MIN_INTERVAL = 60*1000;
451
452    // The minimum amount of time between successive PSS requests for a process.
453    static final int FULL_PSS_MIN_INTERVAL = 10*60*1000;
454
455    // The minimum amount of time between successive PSS requests for a process
456    // when the request is due to the memory state being lowered.
457    static final int FULL_PSS_LOWERED_INTERVAL = 2*60*1000;
458
459    // The rate at which we check for apps using excessive power -- 15 mins.
460    static final int POWER_CHECK_DELAY = (DEBUG_POWER_QUICK ? 2 : 15) * 60*1000;
461
462    // The minimum sample duration we will allow before deciding we have
463    // enough data on wake locks to start killing things.
464    static final int WAKE_LOCK_MIN_CHECK_DURATION = (DEBUG_POWER_QUICK ? 1 : 5) * 60*1000;
465
466    // The minimum sample duration we will allow before deciding we have
467    // enough data on CPU usage to start killing things.
468    static final int CPU_MIN_CHECK_DURATION = (DEBUG_POWER_QUICK ? 1 : 5) * 60*1000;
469
470    // How long we allow a receiver to run before giving up on it.
471    static final int BROADCAST_FG_TIMEOUT = 10*1000;
472    static final int BROADCAST_BG_TIMEOUT = 60*1000;
473
474    // How long we wait until we timeout on key dispatching.
475    static final int KEY_DISPATCHING_TIMEOUT = 5*1000;
476
477    // How long we wait until we timeout on key dispatching during instrumentation.
478    static final int INSTRUMENTATION_KEY_DISPATCHING_TIMEOUT = 60*1000;
479
480    // This is the amount of time an app needs to be running a foreground service before
481    // we will consider it to be doing interaction for usage stats.
482    static final int SERVICE_USAGE_INTERACTION_TIME = 30*60*1000;
483
484    // Maximum amount of time we will allow to elapse before re-reporting usage stats
485    // interaction with foreground processes.
486    static final long USAGE_STATS_INTERACTION_INTERVAL = 24*60*60*1000L;
487
488    // This is the amount of time we allow an app to settle after it goes into the background,
489    // before we start restricting what it can do.
490    static final int BACKGROUND_SETTLE_TIME = 1*60*1000;
491
492    // How long to wait in getAssistContextExtras for the activity and foreground services
493    // to respond with the result.
494    static final int PENDING_ASSIST_EXTRAS_TIMEOUT = 500;
495
496    // How long top wait when going through the modern assist (which doesn't need to block
497    // on getting this result before starting to launch its UI).
498    static final int PENDING_ASSIST_EXTRAS_LONG_TIMEOUT = 2000;
499
500    // Maximum number of persisted Uri grants a package is allowed
501    static final int MAX_PERSISTED_URI_GRANTS = 128;
502
503    static final int MY_PID = Process.myPid();
504
505    static final String[] EMPTY_STRING_ARRAY = new String[0];
506
507    // How many bytes to write into the dropbox log before truncating
508    static final int DROPBOX_MAX_SIZE = 192 * 1024;
509    // Assumes logcat entries average around 100 bytes; that's not perfect stack traces count
510    // as one line, but close enough for now.
511    static final int RESERVED_BYTES_PER_LOGCAT_LINE = 100;
512
513    // Access modes for handleIncomingUser.
514    static final int ALLOW_NON_FULL = 0;
515    static final int ALLOW_NON_FULL_IN_PROFILE = 1;
516    static final int ALLOW_FULL_ONLY = 2;
517
518    // Delay in notifying task stack change listeners (in millis)
519    static final int NOTIFY_TASK_STACK_CHANGE_LISTENERS_DELAY = 100;
520
521    // Necessary ApplicationInfo flags to mark an app as persistent
522    private static final int PERSISTENT_MASK =
523            ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PERSISTENT;
524
525    // Intent sent when remote bugreport collection has been completed
526    private static final String INTENT_REMOTE_BUGREPORT_FINISHED =
527            "android.intent.action.REMOTE_BUGREPORT_FINISHED";
528
529    // Delay to disable app launch boost
530    static final int APP_BOOST_MESSAGE_DELAY = 3000;
531    // Lower delay than APP_BOOST_MESSAGE_DELAY to disable the boost
532    static final int APP_BOOST_TIMEOUT = 2500;
533
534    // Used to indicate that a task is removed it should also be removed from recents.
535    private static final boolean REMOVE_FROM_RECENTS = true;
536    // Used to indicate that an app transition should be animated.
537    static final boolean ANIMATE = true;
538
539    // Determines whether to take full screen screenshots
540    static final boolean TAKE_FULLSCREEN_SCREENSHOTS = true;
541    public static final float FULLSCREEN_SCREENSHOT_SCALE = 0.6f;
542
543    private static native int nativeMigrateToBoost();
544    private static native int nativeMigrateFromBoost();
545    private boolean mIsBoosted = false;
546    private long mBoostStartTime = 0;
547
548    /** All system services */
549    SystemServiceManager mSystemServiceManager;
550
551    private Installer mInstaller;
552
553    /** Run all ActivityStacks through this */
554    final ActivityStackSupervisor mStackSupervisor;
555
556    final ActivityStarter mActivityStarter;
557
558    /** Task stack change listeners. */
559    private final RemoteCallbackList<ITaskStackListener> mTaskStackListeners =
560            new RemoteCallbackList<ITaskStackListener>();
561
562    final InstrumentationReporter mInstrumentationReporter = new InstrumentationReporter();
563
564    public IntentFirewall mIntentFirewall;
565
566    // Whether we should show our dialogs (ANR, crash, etc) or just perform their
567    // default actuion automatically.  Important for devices without direct input
568    // devices.
569    private boolean mShowDialogs = true;
570    private boolean mInVrMode = false;
571
572    // Whether we should use SCHED_FIFO for UI and RenderThreads.
573    private boolean mUseFifoUiScheduling = false;
574
575    BroadcastQueue mFgBroadcastQueue;
576    BroadcastQueue mBgBroadcastQueue;
577    // Convenient for easy iteration over the queues. Foreground is first
578    // so that dispatch of foreground broadcasts gets precedence.
579    final BroadcastQueue[] mBroadcastQueues = new BroadcastQueue[2];
580
581    BroadcastStats mLastBroadcastStats;
582    BroadcastStats mCurBroadcastStats;
583
584    BroadcastQueue broadcastQueueForIntent(Intent intent) {
585        final boolean isFg = (intent.getFlags() & Intent.FLAG_RECEIVER_FOREGROUND) != 0;
586        if (DEBUG_BROADCAST_BACKGROUND) Slog.i(TAG_BROADCAST,
587                "Broadcast intent " + intent + " on "
588                + (isFg ? "foreground" : "background") + " queue");
589        return (isFg) ? mFgBroadcastQueue : mBgBroadcastQueue;
590    }
591
592    /**
593     * Activity we have told the window manager to have key focus.
594     */
595    ActivityRecord mFocusedActivity = null;
596
597    /**
598     * User id of the last activity mFocusedActivity was set to.
599     */
600    private int mLastFocusedUserId;
601
602    /**
603     * If non-null, we are tracking the time the user spends in the currently focused app.
604     */
605    private AppTimeTracker mCurAppTimeTracker;
606
607    /**
608     * List of intents that were used to start the most recent tasks.
609     */
610    final RecentTasks mRecentTasks;
611
612    /**
613     * For addAppTask: cached of the last activity component that was added.
614     */
615    ComponentName mLastAddedTaskComponent;
616
617    /**
618     * For addAppTask: cached of the last activity uid that was added.
619     */
620    int mLastAddedTaskUid;
621
622    /**
623     * For addAppTask: cached of the last ActivityInfo that was added.
624     */
625    ActivityInfo mLastAddedTaskActivity;
626
627    /**
628     * List of packages whitelisted by DevicePolicyManager for locktask. Indexed by userId.
629     */
630    SparseArray<String[]> mLockTaskPackages = new SparseArray<>();
631
632    /**
633     * The package name of the DeviceOwner. This package is not permitted to have its data cleared.
634     */
635    String mDeviceOwnerName;
636
637    final UserController mUserController;
638
639    final AppErrors mAppErrors;
640
641    boolean mDoingSetFocusedActivity;
642
643    public boolean canShowErrorDialogs() {
644        return mShowDialogs && !mSleeping && !mShuttingDown
645                && mLockScreenShown != LOCK_SCREEN_SHOWN;
646    }
647
648    private static final class PriorityState {
649        // Acts as counter for number of synchronized region that needs to acquire 'this' as a lock
650        // the current thread is currently in. When it drops down to zero, we will no longer boost
651        // the thread's priority.
652        private int regionCounter = 0;
653
654        // The thread's previous priority before boosting.
655        private int prevPriority = Integer.MIN_VALUE;
656    }
657
658    static ThreadLocal<PriorityState> sThreadPriorityState = new ThreadLocal<PriorityState>() {
659        @Override protected PriorityState initialValue() {
660            return new PriorityState();
661        }
662    };
663
664    static void boostPriorityForLockedSection() {
665        int tid = Process.myTid();
666        int prevPriority = Process.getThreadPriority(tid);
667        PriorityState state = sThreadPriorityState.get();
668        if (state.regionCounter == 0 && prevPriority > -2) {
669            state.prevPriority = prevPriority;
670            Process.setThreadPriority(tid, -2);
671        }
672        state.regionCounter++;
673    }
674
675    static void resetPriorityAfterLockedSection() {
676        PriorityState state = sThreadPriorityState.get();
677        state.regionCounter--;
678        if (state.regionCounter == 0 && state.prevPriority > -2) {
679            Process.setThreadPriority(Process.myTid(), state.prevPriority);
680        }
681    }
682
683    public class PendingAssistExtras extends Binder implements Runnable {
684        public final ActivityRecord activity;
685        public final Bundle extras;
686        public final Intent intent;
687        public final String hint;
688        public final IResultReceiver receiver;
689        public final int userHandle;
690        public boolean haveResult = false;
691        public Bundle result = null;
692        public AssistStructure structure = null;
693        public AssistContent content = null;
694        public Bundle receiverExtras;
695
696        public PendingAssistExtras(ActivityRecord _activity, Bundle _extras, Intent _intent,
697                String _hint, IResultReceiver _receiver, Bundle _receiverExtras, int _userHandle) {
698            activity = _activity;
699            extras = _extras;
700            intent = _intent;
701            hint = _hint;
702            receiver = _receiver;
703            receiverExtras = _receiverExtras;
704            userHandle = _userHandle;
705        }
706        @Override
707        public void run() {
708            Slog.w(TAG, "getAssistContextExtras failed: timeout retrieving from " + activity);
709            synchronized (this) {
710                haveResult = true;
711                notifyAll();
712            }
713            pendingAssistExtrasTimedOut(this);
714        }
715    }
716
717    final ArrayList<PendingAssistExtras> mPendingAssistExtras
718            = new ArrayList<PendingAssistExtras>();
719
720    /**
721     * Process management.
722     */
723    final ProcessList mProcessList = new ProcessList();
724
725    /**
726     * All of the applications we currently have running organized by name.
727     * The keys are strings of the application package name (as
728     * returned by the package manager), and the keys are ApplicationRecord
729     * objects.
730     */
731    final ProcessMap<ProcessRecord> mProcessNames = new ProcessMap<ProcessRecord>();
732
733    /**
734     * Tracking long-term execution of processes to look for abuse and other
735     * bad app behavior.
736     */
737    final ProcessStatsService mProcessStats;
738
739    /**
740     * The currently running isolated processes.
741     */
742    final SparseArray<ProcessRecord> mIsolatedProcesses = new SparseArray<ProcessRecord>();
743
744    /**
745     * Counter for assigning isolated process uids, to avoid frequently reusing the
746     * same ones.
747     */
748    int mNextIsolatedProcessUid = 0;
749
750    /**
751     * The currently running heavy-weight process, if any.
752     */
753    ProcessRecord mHeavyWeightProcess = null;
754
755    /**
756     * All of the processes we currently have running organized by pid.
757     * The keys are the pid running the application.
758     *
759     * <p>NOTE: This object is protected by its own lock, NOT the global
760     * activity manager lock!
761     */
762    final SparseArray<ProcessRecord> mPidsSelfLocked = new SparseArray<ProcessRecord>();
763
764    /**
765     * All of the processes that have been forced to be foreground.  The key
766     * is the pid of the caller who requested it (we hold a death
767     * link on it).
768     */
769    abstract class ForegroundToken implements IBinder.DeathRecipient {
770        int pid;
771        IBinder token;
772    }
773    final SparseArray<ForegroundToken> mForegroundProcesses = new SparseArray<ForegroundToken>();
774
775    /**
776     * List of records for processes that someone had tried to start before the
777     * system was ready.  We don't start them at that point, but ensure they
778     * are started by the time booting is complete.
779     */
780    final ArrayList<ProcessRecord> mProcessesOnHold = new ArrayList<ProcessRecord>();
781
782    /**
783     * List of persistent applications that are in the process
784     * of being started.
785     */
786    final ArrayList<ProcessRecord> mPersistentStartingProcesses = new ArrayList<ProcessRecord>();
787
788    /**
789     * Processes that are being forcibly torn down.
790     */
791    final ArrayList<ProcessRecord> mRemovedProcesses = new ArrayList<ProcessRecord>();
792
793    /**
794     * List of running applications, sorted by recent usage.
795     * The first entry in the list is the least recently used.
796     */
797    final ArrayList<ProcessRecord> mLruProcesses = new ArrayList<ProcessRecord>();
798
799    /**
800     * Where in mLruProcesses that the processes hosting activities start.
801     */
802    int mLruProcessActivityStart = 0;
803
804    /**
805     * Where in mLruProcesses that the processes hosting services start.
806     * This is after (lower index) than mLruProcessesActivityStart.
807     */
808    int mLruProcessServiceStart = 0;
809
810    /**
811     * List of processes that should gc as soon as things are idle.
812     */
813    final ArrayList<ProcessRecord> mProcessesToGc = new ArrayList<ProcessRecord>();
814
815    /**
816     * Processes we want to collect PSS data from.
817     */
818    final ArrayList<ProcessRecord> mPendingPssProcesses = new ArrayList<ProcessRecord>();
819
820    private boolean mBinderTransactionTrackingEnabled = false;
821
822    /**
823     * Last time we requested PSS data of all processes.
824     */
825    long mLastFullPssTime = SystemClock.uptimeMillis();
826
827    /**
828     * If set, the next time we collect PSS data we should do a full collection
829     * with data from native processes and the kernel.
830     */
831    boolean mFullPssPending = false;
832
833    /**
834     * This is the process holding what we currently consider to be
835     * the "home" activity.
836     */
837    ProcessRecord mHomeProcess;
838
839    /**
840     * This is the process holding the activity the user last visited that
841     * is in a different process from the one they are currently in.
842     */
843    ProcessRecord mPreviousProcess;
844
845    /**
846     * The time at which the previous process was last visible.
847     */
848    long mPreviousProcessVisibleTime;
849
850    /**
851     * Track all uids that have actively running processes.
852     */
853    final SparseArray<UidRecord> mActiveUids = new SparseArray<>();
854
855    /**
856     * This is for verifying the UID report flow.
857     */
858    static final boolean VALIDATE_UID_STATES = true;
859    final SparseArray<UidRecord> mValidateUids = new SparseArray<>();
860
861    /**
862     * Packages that the user has asked to have run in screen size
863     * compatibility mode instead of filling the screen.
864     */
865    final CompatModePackages mCompatModePackages;
866
867    /**
868     * Set of IntentSenderRecord objects that are currently active.
869     */
870    final HashMap<PendingIntentRecord.Key, WeakReference<PendingIntentRecord>> mIntentSenderRecords
871            = new HashMap<PendingIntentRecord.Key, WeakReference<PendingIntentRecord>>();
872
873    /**
874     * Fingerprints (hashCode()) of stack traces that we've
875     * already logged DropBox entries for.  Guarded by itself.  If
876     * something (rogue user app) forces this over
877     * MAX_DUP_SUPPRESSED_STACKS entries, the contents are cleared.
878     */
879    private final HashSet<Integer> mAlreadyLoggedViolatedStacks = new HashSet<Integer>();
880    private static final int MAX_DUP_SUPPRESSED_STACKS = 5000;
881
882    /**
883     * Strict Mode background batched logging state.
884     *
885     * The string buffer is guarded by itself, and its lock is also
886     * used to determine if another batched write is already
887     * in-flight.
888     */
889    private final StringBuilder mStrictModeBuffer = new StringBuilder();
890
891    /**
892     * Keeps track of all IIntentReceivers that have been registered for broadcasts.
893     * Hash keys are the receiver IBinder, hash value is a ReceiverList.
894     */
895    final HashMap<IBinder, ReceiverList> mRegisteredReceivers = new HashMap<>();
896
897    /**
898     * Resolver for broadcast intents to registered receivers.
899     * Holds BroadcastFilter (subclass of IntentFilter).
900     */
901    final IntentResolver<BroadcastFilter, BroadcastFilter> mReceiverResolver
902            = new IntentResolver<BroadcastFilter, BroadcastFilter>() {
903        @Override
904        protected boolean allowFilterResult(
905                BroadcastFilter filter, List<BroadcastFilter> dest) {
906            IBinder target = filter.receiverList.receiver.asBinder();
907            for (int i = dest.size() - 1; i >= 0; i--) {
908                if (dest.get(i).receiverList.receiver.asBinder() == target) {
909                    return false;
910                }
911            }
912            return true;
913        }
914
915        @Override
916        protected BroadcastFilter newResult(BroadcastFilter filter, int match, int userId) {
917            if (userId == UserHandle.USER_ALL || filter.owningUserId == UserHandle.USER_ALL
918                    || userId == filter.owningUserId) {
919                return super.newResult(filter, match, userId);
920            }
921            return null;
922        }
923
924        @Override
925        protected BroadcastFilter[] newArray(int size) {
926            return new BroadcastFilter[size];
927        }
928
929        @Override
930        protected boolean isPackageForFilter(String packageName, BroadcastFilter filter) {
931            return packageName.equals(filter.packageName);
932        }
933    };
934
935    /**
936     * State of all active sticky broadcasts per user.  Keys are the action of the
937     * sticky Intent, values are an ArrayList of all broadcasted intents with
938     * that action (which should usually be one).  The SparseArray is keyed
939     * by the user ID the sticky is for, and can include UserHandle.USER_ALL
940     * for stickies that are sent to all users.
941     */
942    final SparseArray<ArrayMap<String, ArrayList<Intent>>> mStickyBroadcasts =
943            new SparseArray<ArrayMap<String, ArrayList<Intent>>>();
944
945    final ActiveServices mServices;
946
947    final static class Association {
948        final int mSourceUid;
949        final String mSourceProcess;
950        final int mTargetUid;
951        final ComponentName mTargetComponent;
952        final String mTargetProcess;
953
954        int mCount;
955        long mTime;
956
957        int mNesting;
958        long mStartTime;
959
960        // states of the source process when the bind occurred.
961        int mLastState = ActivityManager.MAX_PROCESS_STATE + 1;
962        long mLastStateUptime;
963        long[] mStateTimes = new long[ActivityManager.MAX_PROCESS_STATE
964                - ActivityManager.MIN_PROCESS_STATE+1];
965
966        Association(int sourceUid, String sourceProcess, int targetUid,
967                ComponentName targetComponent, String targetProcess) {
968            mSourceUid = sourceUid;
969            mSourceProcess = sourceProcess;
970            mTargetUid = targetUid;
971            mTargetComponent = targetComponent;
972            mTargetProcess = targetProcess;
973        }
974    }
975
976    /**
977     * When service association tracking is enabled, this is all of the associations we
978     * have seen.  Mapping is target uid -> target component -> source uid -> source process name
979     * -> association data.
980     */
981    final SparseArray<ArrayMap<ComponentName, SparseArray<ArrayMap<String, Association>>>>
982            mAssociations = new SparseArray<>();
983    boolean mTrackingAssociations;
984
985    /**
986     * Backup/restore process management
987     */
988    String mBackupAppName = null;
989    BackupRecord mBackupTarget = null;
990
991    final ProviderMap mProviderMap;
992
993    /**
994     * List of content providers who have clients waiting for them.  The
995     * application is currently being launched and the provider will be
996     * removed from this list once it is published.
997     */
998    final ArrayList<ContentProviderRecord> mLaunchingProviders
999            = new ArrayList<ContentProviderRecord>();
1000
1001    /**
1002     * File storing persisted {@link #mGrantedUriPermissions}.
1003     */
1004    private final AtomicFile mGrantFile;
1005
1006    /** XML constants used in {@link #mGrantFile} */
1007    private static final String TAG_URI_GRANTS = "uri-grants";
1008    private static final String TAG_URI_GRANT = "uri-grant";
1009    private static final String ATTR_USER_HANDLE = "userHandle";
1010    private static final String ATTR_SOURCE_USER_ID = "sourceUserId";
1011    private static final String ATTR_TARGET_USER_ID = "targetUserId";
1012    private static final String ATTR_SOURCE_PKG = "sourcePkg";
1013    private static final String ATTR_TARGET_PKG = "targetPkg";
1014    private static final String ATTR_URI = "uri";
1015    private static final String ATTR_MODE_FLAGS = "modeFlags";
1016    private static final String ATTR_CREATED_TIME = "createdTime";
1017    private static final String ATTR_PREFIX = "prefix";
1018
1019    /**
1020     * Global set of specific {@link Uri} permissions that have been granted.
1021     * This optimized lookup structure maps from {@link UriPermission#targetUid}
1022     * to {@link UriPermission#uri} to {@link UriPermission}.
1023     */
1024    @GuardedBy("this")
1025    private final SparseArray<ArrayMap<GrantUri, UriPermission>>
1026            mGrantedUriPermissions = new SparseArray<ArrayMap<GrantUri, UriPermission>>();
1027
1028    public static class GrantUri {
1029        public final int sourceUserId;
1030        public final Uri uri;
1031        public boolean prefix;
1032
1033        public GrantUri(int sourceUserId, Uri uri, boolean prefix) {
1034            this.sourceUserId = sourceUserId;
1035            this.uri = uri;
1036            this.prefix = prefix;
1037        }
1038
1039        @Override
1040        public int hashCode() {
1041            int hashCode = 1;
1042            hashCode = 31 * hashCode + sourceUserId;
1043            hashCode = 31 * hashCode + uri.hashCode();
1044            hashCode = 31 * hashCode + (prefix ? 1231 : 1237);
1045            return hashCode;
1046        }
1047
1048        @Override
1049        public boolean equals(Object o) {
1050            if (o instanceof GrantUri) {
1051                GrantUri other = (GrantUri) o;
1052                return uri.equals(other.uri) && (sourceUserId == other.sourceUserId)
1053                        && prefix == other.prefix;
1054            }
1055            return false;
1056        }
1057
1058        @Override
1059        public String toString() {
1060            String result = Integer.toString(sourceUserId) + " @ " + uri.toString();
1061            if (prefix) result += " [prefix]";
1062            return result;
1063        }
1064
1065        public String toSafeString() {
1066            String result = Integer.toString(sourceUserId) + " @ " + uri.toSafeString();
1067            if (prefix) result += " [prefix]";
1068            return result;
1069        }
1070
1071        public static GrantUri resolve(int defaultSourceUserHandle, Uri uri) {
1072            return new GrantUri(ContentProvider.getUserIdFromUri(uri, defaultSourceUserHandle),
1073                    ContentProvider.getUriWithoutUserId(uri), false);
1074        }
1075    }
1076
1077    CoreSettingsObserver mCoreSettingsObserver;
1078
1079    FontScaleSettingObserver mFontScaleSettingObserver;
1080
1081    private final class FontScaleSettingObserver extends ContentObserver {
1082        private final Uri mFontScaleUri = Settings.System.getUriFor(FONT_SCALE);
1083
1084        public FontScaleSettingObserver() {
1085            super(mHandler);
1086            ContentResolver resolver = mContext.getContentResolver();
1087            resolver.registerContentObserver(mFontScaleUri, false, this, UserHandle.USER_ALL);
1088        }
1089
1090        @Override
1091        public void onChange(boolean selfChange, Uri uri, @UserIdInt int userId) {
1092            if (mFontScaleUri.equals(uri)) {
1093                updateFontScaleIfNeeded(userId);
1094            }
1095        }
1096    }
1097
1098    /**
1099     * Thread-local storage used to carry caller permissions over through
1100     * indirect content-provider access.
1101     */
1102    private class Identity {
1103        public final IBinder token;
1104        public final int pid;
1105        public final int uid;
1106
1107        Identity(IBinder _token, int _pid, int _uid) {
1108            token = _token;
1109            pid = _pid;
1110            uid = _uid;
1111        }
1112    }
1113
1114    private static final ThreadLocal<Identity> sCallerIdentity = new ThreadLocal<Identity>();
1115
1116    /**
1117     * All information we have collected about the runtime performance of
1118     * any user id that can impact battery performance.
1119     */
1120    final BatteryStatsService mBatteryStatsService;
1121
1122    /**
1123     * Information about component usage
1124     */
1125    UsageStatsManagerInternal mUsageStatsService;
1126
1127    /**
1128     * Access to DeviceIdleController service.
1129     */
1130    DeviceIdleController.LocalService mLocalDeviceIdleController;
1131
1132    /**
1133     * Information about and control over application operations
1134     */
1135    final AppOpsService mAppOpsService;
1136
1137    /**
1138     * Current configuration information.  HistoryRecord objects are given
1139     * a reference to this object to indicate which configuration they are
1140     * currently running in, so this object must be kept immutable.
1141     */
1142    Configuration mConfiguration = new Configuration();
1143
1144    /**
1145     * Current sequencing integer of the configuration, for skipping old
1146     * configurations.
1147     */
1148    int mConfigurationSeq = 0;
1149
1150    boolean mSuppressResizeConfigChanges = false;
1151
1152    /**
1153     * Hardware-reported OpenGLES version.
1154     */
1155    final int GL_ES_VERSION;
1156
1157    /**
1158     * List of initialization arguments to pass to all processes when binding applications to them.
1159     * For example, references to the commonly used services.
1160     */
1161    HashMap<String, IBinder> mAppBindArgs;
1162    HashMap<String, IBinder> mIsolatedAppBindArgs;
1163
1164    /**
1165     * Temporary to avoid allocations.  Protected by main lock.
1166     */
1167    final StringBuilder mStringBuilder = new StringBuilder(256);
1168
1169    /**
1170     * Used to control how we initialize the service.
1171     */
1172    ComponentName mTopComponent;
1173    String mTopAction = Intent.ACTION_MAIN;
1174    String mTopData;
1175
1176    volatile boolean mProcessesReady = false;
1177    volatile boolean mSystemReady = false;
1178    volatile boolean mOnBattery = false;
1179    volatile int mFactoryTest;
1180
1181    @GuardedBy("this") boolean mBooting = false;
1182    @GuardedBy("this") boolean mCallFinishBooting = false;
1183    @GuardedBy("this") boolean mBootAnimationComplete = false;
1184    @GuardedBy("this") boolean mLaunchWarningShown = false;
1185    @GuardedBy("this") boolean mCheckedForSetup = false;
1186
1187    Context mContext;
1188
1189    /**
1190     * The time at which we will allow normal application switches again,
1191     * after a call to {@link #stopAppSwitches()}.
1192     */
1193    long mAppSwitchesAllowedTime;
1194
1195    /**
1196     * This is set to true after the first switch after mAppSwitchesAllowedTime
1197     * is set; any switches after that will clear the time.
1198     */
1199    boolean mDidAppSwitch;
1200
1201    /**
1202     * Last time (in realtime) at which we checked for power usage.
1203     */
1204    long mLastPowerCheckRealtime;
1205
1206    /**
1207     * Last time (in uptime) at which we checked for power usage.
1208     */
1209    long mLastPowerCheckUptime;
1210
1211    /**
1212     * Set while we are wanting to sleep, to prevent any
1213     * activities from being started/resumed.
1214     */
1215    private boolean mSleeping = false;
1216
1217    /**
1218     * The process state used for processes that are running the top activities.
1219     * This changes between TOP and TOP_SLEEPING to following mSleeping.
1220     */
1221    int mTopProcessState = ActivityManager.PROCESS_STATE_TOP;
1222
1223    /**
1224     * Set while we are running a voice interaction.  This overrides
1225     * sleeping while it is active.
1226     */
1227    private IVoiceInteractionSession mRunningVoice;
1228
1229    /**
1230     * For some direct access we need to power manager.
1231     */
1232    PowerManagerInternal mLocalPowerManager;
1233
1234    /**
1235     * We want to hold a wake lock while running a voice interaction session, since
1236     * this may happen with the screen off and we need to keep the CPU running to
1237     * be able to continue to interact with the user.
1238     */
1239    PowerManager.WakeLock mVoiceWakeLock;
1240
1241    /**
1242     * State of external calls telling us if the device is awake or asleep.
1243     */
1244    private int mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
1245
1246    /**
1247     * A list of tokens that cause the top activity to be put to sleep.
1248     * They are used by components that may hide and block interaction with underlying
1249     * activities.
1250     */
1251    final ArrayList<SleepToken> mSleepTokens = new ArrayList<SleepToken>();
1252
1253    static final int LOCK_SCREEN_HIDDEN = 0;
1254    static final int LOCK_SCREEN_LEAVING = 1;
1255    static final int LOCK_SCREEN_SHOWN = 2;
1256    /**
1257     * State of external call telling us if the lock screen is shown.
1258     */
1259    int mLockScreenShown = LOCK_SCREEN_HIDDEN;
1260
1261    /**
1262     * Set if we are shutting down the system, similar to sleeping.
1263     */
1264    boolean mShuttingDown = false;
1265
1266    /**
1267     * Current sequence id for oom_adj computation traversal.
1268     */
1269    int mAdjSeq = 0;
1270
1271    /**
1272     * Current sequence id for process LRU updating.
1273     */
1274    int mLruSeq = 0;
1275
1276    /**
1277     * Keep track of the non-cached/empty process we last found, to help
1278     * determine how to distribute cached/empty processes next time.
1279     */
1280    int mNumNonCachedProcs = 0;
1281
1282    /**
1283     * Keep track of the number of cached hidden procs, to balance oom adj
1284     * distribution between those and empty procs.
1285     */
1286    int mNumCachedHiddenProcs = 0;
1287
1288    /**
1289     * Keep track of the number of service processes we last found, to
1290     * determine on the next iteration which should be B services.
1291     */
1292    int mNumServiceProcs = 0;
1293    int mNewNumAServiceProcs = 0;
1294    int mNewNumServiceProcs = 0;
1295
1296    /**
1297     * Allow the current computed overall memory level of the system to go down?
1298     * This is set to false when we are killing processes for reasons other than
1299     * memory management, so that the now smaller process list will not be taken as
1300     * an indication that memory is tighter.
1301     */
1302    boolean mAllowLowerMemLevel = false;
1303
1304    /**
1305     * The last computed memory level, for holding when we are in a state that
1306     * processes are going away for other reasons.
1307     */
1308    int mLastMemoryLevel = ProcessStats.ADJ_MEM_FACTOR_NORMAL;
1309
1310    /**
1311     * The last total number of process we have, to determine if changes actually look
1312     * like a shrinking number of process due to lower RAM.
1313     */
1314    int mLastNumProcesses;
1315
1316    /**
1317     * The uptime of the last time we performed idle maintenance.
1318     */
1319    long mLastIdleTime = SystemClock.uptimeMillis();
1320
1321    /**
1322     * Total time spent with RAM that has been added in the past since the last idle time.
1323     */
1324    long mLowRamTimeSinceLastIdle = 0;
1325
1326    /**
1327     * If RAM is currently low, when that horrible situation started.
1328     */
1329    long mLowRamStartTime = 0;
1330
1331    /**
1332     * For reporting to battery stats the current top application.
1333     */
1334    private String mCurResumedPackage = null;
1335    private int mCurResumedUid = -1;
1336
1337    /**
1338     * For reporting to battery stats the apps currently running foreground
1339     * service.  The ProcessMap is package/uid tuples; each of these contain
1340     * an array of the currently foreground processes.
1341     */
1342    final ProcessMap<ArrayList<ProcessRecord>> mForegroundPackages
1343            = new ProcessMap<ArrayList<ProcessRecord>>();
1344
1345    /**
1346     * This is set if we had to do a delayed dexopt of an app before launching
1347     * it, to increase the ANR timeouts in that case.
1348     */
1349    boolean mDidDexOpt;
1350
1351    /**
1352     * Set if the systemServer made a call to enterSafeMode.
1353     */
1354    boolean mSafeMode;
1355
1356    /**
1357     * If true, we are running under a test environment so will sample PSS from processes
1358     * much more rapidly to try to collect better data when the tests are rapidly
1359     * running through apps.
1360     */
1361    boolean mTestPssMode = false;
1362
1363    String mDebugApp = null;
1364    boolean mWaitForDebugger = false;
1365    boolean mDebugTransient = false;
1366    String mOrigDebugApp = null;
1367    boolean mOrigWaitForDebugger = false;
1368    boolean mAlwaysFinishActivities = false;
1369    boolean mLenientBackgroundCheck = false;
1370    boolean mForceResizableActivities;
1371    boolean mSupportsMultiWindow;
1372    boolean mSupportsFreeformWindowManagement;
1373    boolean mSupportsPictureInPicture;
1374    boolean mSupportsLeanbackOnly;
1375    Rect mDefaultPinnedStackBounds;
1376    IActivityController mController = null;
1377    boolean mControllerIsAMonkey = false;
1378    String mProfileApp = null;
1379    ProcessRecord mProfileProc = null;
1380    String mProfileFile;
1381    ParcelFileDescriptor mProfileFd;
1382    int mSamplingInterval = 0;
1383    boolean mAutoStopProfiler = false;
1384    int mProfileType = 0;
1385    final ProcessMap<Pair<Long, String>> mMemWatchProcesses = new ProcessMap<>();
1386    String mMemWatchDumpProcName;
1387    String mMemWatchDumpFile;
1388    int mMemWatchDumpPid;
1389    int mMemWatchDumpUid;
1390    String mTrackAllocationApp = null;
1391    String mNativeDebuggingApp = null;
1392
1393    final long[] mTmpLong = new long[2];
1394
1395    static final class ProcessChangeItem {
1396        static final int CHANGE_ACTIVITIES = 1<<0;
1397        static final int CHANGE_PROCESS_STATE = 1<<1;
1398        int changes;
1399        int uid;
1400        int pid;
1401        int processState;
1402        boolean foregroundActivities;
1403    }
1404
1405    final RemoteCallbackList<IProcessObserver> mProcessObservers = new RemoteCallbackList<>();
1406    ProcessChangeItem[] mActiveProcessChanges = new ProcessChangeItem[5];
1407
1408    final ArrayList<ProcessChangeItem> mPendingProcessChanges = new ArrayList<>();
1409    final ArrayList<ProcessChangeItem> mAvailProcessChanges = new ArrayList<>();
1410
1411    final RemoteCallbackList<IUidObserver> mUidObservers = new RemoteCallbackList<>();
1412    UidRecord.ChangeItem[] mActiveUidChanges = new UidRecord.ChangeItem[5];
1413
1414    final ArrayList<UidRecord.ChangeItem> mPendingUidChanges = new ArrayList<>();
1415    final ArrayList<UidRecord.ChangeItem> mAvailUidChanges = new ArrayList<>();
1416
1417    /**
1418     * Runtime CPU use collection thread.  This object's lock is used to
1419     * perform synchronization with the thread (notifying it to run).
1420     */
1421    final Thread mProcessCpuThread;
1422
1423    /**
1424     * Used to collect per-process CPU use for ANRs, battery stats, etc.
1425     * Must acquire this object's lock when accessing it.
1426     * NOTE: this lock will be held while doing long operations (trawling
1427     * through all processes in /proc), so it should never be acquired by
1428     * any critical paths such as when holding the main activity manager lock.
1429     */
1430    final ProcessCpuTracker mProcessCpuTracker = new ProcessCpuTracker(
1431            MONITOR_THREAD_CPU_USAGE);
1432    final AtomicLong mLastCpuTime = new AtomicLong(0);
1433    final AtomicBoolean mProcessCpuMutexFree = new AtomicBoolean(true);
1434
1435    long mLastWriteTime = 0;
1436
1437    /**
1438     * Used to retain an update lock when the foreground activity is in
1439     * immersive mode.
1440     */
1441    final UpdateLock mUpdateLock = new UpdateLock("immersive");
1442
1443    /**
1444     * Set to true after the system has finished booting.
1445     */
1446    boolean mBooted = false;
1447
1448    int mProcessLimit = ProcessList.MAX_CACHED_APPS;
1449    int mProcessLimitOverride = -1;
1450
1451    WindowManagerService mWindowManager;
1452    final ActivityThread mSystemThread;
1453
1454    private final class AppDeathRecipient implements IBinder.DeathRecipient {
1455        final ProcessRecord mApp;
1456        final int mPid;
1457        final IApplicationThread mAppThread;
1458
1459        AppDeathRecipient(ProcessRecord app, int pid,
1460                IApplicationThread thread) {
1461            if (DEBUG_ALL) Slog.v(
1462                TAG, "New death recipient " + this
1463                + " for thread " + thread.asBinder());
1464            mApp = app;
1465            mPid = pid;
1466            mAppThread = thread;
1467        }
1468
1469        @Override
1470        public void binderDied() {
1471            if (DEBUG_ALL) Slog.v(
1472                TAG, "Death received in " + this
1473                + " for thread " + mAppThread.asBinder());
1474            synchronized(ActivityManagerService.this) {
1475                appDiedLocked(mApp, mPid, mAppThread, true);
1476            }
1477        }
1478    }
1479
1480    static final int SHOW_ERROR_UI_MSG = 1;
1481    static final int SHOW_NOT_RESPONDING_UI_MSG = 2;
1482    static final int SHOW_FACTORY_ERROR_UI_MSG = 3;
1483    static final int UPDATE_CONFIGURATION_MSG = 4;
1484    static final int GC_BACKGROUND_PROCESSES_MSG = 5;
1485    static final int WAIT_FOR_DEBUGGER_UI_MSG = 6;
1486    static final int SERVICE_TIMEOUT_MSG = 12;
1487    static final int UPDATE_TIME_ZONE = 13;
1488    static final int SHOW_UID_ERROR_UI_MSG = 14;
1489    static final int SHOW_FINGERPRINT_ERROR_UI_MSG = 15;
1490    static final int PROC_START_TIMEOUT_MSG = 20;
1491    static final int DO_PENDING_ACTIVITY_LAUNCHES_MSG = 21;
1492    static final int KILL_APPLICATION_MSG = 22;
1493    static final int FINALIZE_PENDING_INTENT_MSG = 23;
1494    static final int POST_HEAVY_NOTIFICATION_MSG = 24;
1495    static final int CANCEL_HEAVY_NOTIFICATION_MSG = 25;
1496    static final int SHOW_STRICT_MODE_VIOLATION_UI_MSG = 26;
1497    static final int CHECK_EXCESSIVE_WAKE_LOCKS_MSG = 27;
1498    static final int CLEAR_DNS_CACHE_MSG = 28;
1499    static final int UPDATE_HTTP_PROXY_MSG = 29;
1500    static final int SHOW_COMPAT_MODE_DIALOG_UI_MSG = 30;
1501    static final int DISPATCH_PROCESSES_CHANGED_UI_MSG = 31;
1502    static final int DISPATCH_PROCESS_DIED_UI_MSG = 32;
1503    static final int REPORT_MEM_USAGE_MSG = 33;
1504    static final int REPORT_USER_SWITCH_MSG = 34;
1505    static final int CONTINUE_USER_SWITCH_MSG = 35;
1506    static final int USER_SWITCH_TIMEOUT_MSG = 36;
1507    static final int IMMERSIVE_MODE_LOCK_MSG = 37;
1508    static final int PERSIST_URI_GRANTS_MSG = 38;
1509    static final int REQUEST_ALL_PSS_MSG = 39;
1510    static final int START_PROFILES_MSG = 40;
1511    static final int UPDATE_TIME = 41;
1512    static final int SYSTEM_USER_START_MSG = 42;
1513    static final int SYSTEM_USER_CURRENT_MSG = 43;
1514    static final int ENTER_ANIMATION_COMPLETE_MSG = 44;
1515    static final int FINISH_BOOTING_MSG = 45;
1516    static final int START_USER_SWITCH_UI_MSG = 46;
1517    static final int SEND_LOCALE_TO_MOUNT_DAEMON_MSG = 47;
1518    static final int DISMISS_DIALOG_UI_MSG = 48;
1519    static final int NOTIFY_TASK_STACK_CHANGE_LISTENERS_MSG = 49;
1520    static final int NOTIFY_CLEARTEXT_NETWORK_MSG = 50;
1521    static final int POST_DUMP_HEAP_NOTIFICATION_MSG = 51;
1522    static final int DELETE_DUMPHEAP_MSG = 52;
1523    static final int FOREGROUND_PROFILE_CHANGED_MSG = 53;
1524    static final int DISPATCH_UIDS_CHANGED_UI_MSG = 54;
1525    static final int REPORT_TIME_TRACKER_MSG = 55;
1526    static final int REPORT_USER_SWITCH_COMPLETE_MSG = 56;
1527    static final int SHUTDOWN_UI_AUTOMATION_CONNECTION_MSG = 57;
1528    static final int APP_BOOST_DEACTIVATE_MSG = 58;
1529    static final int CONTENT_PROVIDER_PUBLISH_TIMEOUT_MSG = 59;
1530    static final int IDLE_UIDS_MSG = 60;
1531    static final int SYSTEM_USER_UNLOCK_MSG = 61;
1532    static final int LOG_STACK_STATE = 62;
1533    static final int VR_MODE_CHANGE_MSG = 63;
1534    static final int NOTIFY_ACTIVITY_PINNED_LISTENERS_MSG = 64;
1535    static final int NOTIFY_PINNED_ACTIVITY_RESTART_ATTEMPT_LISTENERS_MSG = 65;
1536    static final int NOTIFY_PINNED_STACK_ANIMATION_ENDED_LISTENERS_MSG = 66;
1537    static final int NOTIFY_FORCED_RESIZABLE_MSG = 67;
1538    static final int NOTIFY_ACTIVITY_DISMISSING_DOCKED_STACK_MSG = 68;
1539    static final int VR_MODE_APPLY_IF_NEEDED_MSG = 69;
1540    static final int SHOW_UNSUPPORTED_DISPLAY_SIZE_DIALOG_MSG = 70;
1541
1542    static final int FIRST_ACTIVITY_STACK_MSG = 100;
1543    static final int FIRST_BROADCAST_QUEUE_MSG = 200;
1544    static final int FIRST_COMPAT_MODE_MSG = 300;
1545    static final int FIRST_SUPERVISOR_STACK_MSG = 100;
1546
1547    static ServiceThread sKillThread = null;
1548    static KillHandler sKillHandler = null;
1549
1550    CompatModeDialog mCompatModeDialog;
1551    UnsupportedDisplaySizeDialog mUnsupportedDisplaySizeDialog;
1552    long mLastMemUsageReportTime = 0;
1553
1554    /**
1555     * Flag whether the current user is a "monkey", i.e. whether
1556     * the UI is driven by a UI automation tool.
1557     */
1558    private boolean mUserIsMonkey;
1559
1560    /** Flag whether the device has a Recents UI */
1561    boolean mHasRecents;
1562
1563    /** The dimensions of the thumbnails in the Recents UI. */
1564    int mThumbnailWidth;
1565    int mThumbnailHeight;
1566    float mFullscreenThumbnailScale;
1567
1568    final ServiceThread mHandlerThread;
1569    final MainHandler mHandler;
1570    final UiHandler mUiHandler;
1571
1572    PackageManagerInternal mPackageManagerInt;
1573
1574    // VoiceInteraction session ID that changes for each new request except when
1575    // being called for multiwindow assist in a single session.
1576    private int mViSessionId = 1000;
1577
1578    final class KillHandler extends Handler {
1579        static final int KILL_PROCESS_GROUP_MSG = 4000;
1580
1581        public KillHandler(Looper looper) {
1582            super(looper, null, true);
1583        }
1584
1585        @Override
1586        public void handleMessage(Message msg) {
1587            switch (msg.what) {
1588                case KILL_PROCESS_GROUP_MSG:
1589                {
1590                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "killProcessGroup");
1591                    Process.killProcessGroup(msg.arg1 /* uid */, msg.arg2 /* pid */);
1592                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1593                }
1594                break;
1595
1596                default:
1597                    super.handleMessage(msg);
1598            }
1599        }
1600    }
1601
1602    final class UiHandler extends Handler {
1603        public UiHandler() {
1604            super(com.android.server.UiThread.get().getLooper(), null, true);
1605        }
1606
1607        @Override
1608        public void handleMessage(Message msg) {
1609            switch (msg.what) {
1610            case SHOW_ERROR_UI_MSG: {
1611                mAppErrors.handleShowAppErrorUi(msg);
1612                ensureBootCompleted();
1613            } break;
1614            case SHOW_NOT_RESPONDING_UI_MSG: {
1615                mAppErrors.handleShowAnrUi(msg);
1616                ensureBootCompleted();
1617            } break;
1618            case SHOW_STRICT_MODE_VIOLATION_UI_MSG: {
1619                HashMap<String, Object> data = (HashMap<String, Object>) msg.obj;
1620                synchronized (ActivityManagerService.this) {
1621                    ProcessRecord proc = (ProcessRecord) data.get("app");
1622                    if (proc == null) {
1623                        Slog.e(TAG, "App not found when showing strict mode dialog.");
1624                        break;
1625                    }
1626                    if (proc.crashDialog != null) {
1627                        Slog.e(TAG, "App already has strict mode dialog: " + proc);
1628                        return;
1629                    }
1630                    AppErrorResult res = (AppErrorResult) data.get("result");
1631                    if (mShowDialogs && !mSleeping && !mShuttingDown) {
1632                        Dialog d = new StrictModeViolationDialog(mContext,
1633                                ActivityManagerService.this, res, proc);
1634                        d.show();
1635                        proc.crashDialog = d;
1636                    } else {
1637                        // The device is asleep, so just pretend that the user
1638                        // saw a crash dialog and hit "force quit".
1639                        res.set(0);
1640                    }
1641                }
1642                ensureBootCompleted();
1643            } break;
1644            case SHOW_FACTORY_ERROR_UI_MSG: {
1645                Dialog d = new FactoryErrorDialog(
1646                    mContext, msg.getData().getCharSequence("msg"));
1647                d.show();
1648                ensureBootCompleted();
1649            } break;
1650            case WAIT_FOR_DEBUGGER_UI_MSG: {
1651                synchronized (ActivityManagerService.this) {
1652                    ProcessRecord app = (ProcessRecord)msg.obj;
1653                    if (msg.arg1 != 0) {
1654                        if (!app.waitedForDebugger) {
1655                            Dialog d = new AppWaitingForDebuggerDialog(
1656                                    ActivityManagerService.this,
1657                                    mContext, app);
1658                            app.waitDialog = d;
1659                            app.waitedForDebugger = true;
1660                            d.show();
1661                        }
1662                    } else {
1663                        if (app.waitDialog != null) {
1664                            app.waitDialog.dismiss();
1665                            app.waitDialog = null;
1666                        }
1667                    }
1668                }
1669            } break;
1670            case SHOW_UID_ERROR_UI_MSG: {
1671                if (mShowDialogs) {
1672                    AlertDialog d = new BaseErrorDialog(mContext);
1673                    d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ERROR);
1674                    d.setCancelable(false);
1675                    d.setTitle(mContext.getText(R.string.android_system_label));
1676                    d.setMessage(mContext.getText(R.string.system_error_wipe_data));
1677                    d.setButton(DialogInterface.BUTTON_POSITIVE, mContext.getText(R.string.ok),
1678                            obtainMessage(DISMISS_DIALOG_UI_MSG, d));
1679                    d.show();
1680                }
1681            } break;
1682            case SHOW_FINGERPRINT_ERROR_UI_MSG: {
1683                if (mShowDialogs) {
1684                    AlertDialog d = new BaseErrorDialog(mContext);
1685                    d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ERROR);
1686                    d.setCancelable(false);
1687                    d.setTitle(mContext.getText(R.string.android_system_label));
1688                    d.setMessage(mContext.getText(R.string.system_error_manufacturer));
1689                    d.setButton(DialogInterface.BUTTON_POSITIVE, mContext.getText(R.string.ok),
1690                            obtainMessage(DISMISS_DIALOG_UI_MSG, d));
1691                    d.show();
1692                }
1693            } break;
1694            case SHOW_COMPAT_MODE_DIALOG_UI_MSG: {
1695                synchronized (ActivityManagerService.this) {
1696                    ActivityRecord ar = (ActivityRecord) msg.obj;
1697                    if (mCompatModeDialog != null) {
1698                        if (mCompatModeDialog.mAppInfo.packageName.equals(
1699                                ar.info.applicationInfo.packageName)) {
1700                            return;
1701                        }
1702                        mCompatModeDialog.dismiss();
1703                        mCompatModeDialog = null;
1704                    }
1705                    if (ar != null && false) {
1706                        if (mCompatModePackages.getPackageAskCompatModeLocked(
1707                                ar.packageName)) {
1708                            int mode = mCompatModePackages.computeCompatModeLocked(
1709                                    ar.info.applicationInfo);
1710                            if (mode == ActivityManager.COMPAT_MODE_DISABLED
1711                                    || mode == ActivityManager.COMPAT_MODE_ENABLED) {
1712                                mCompatModeDialog = new CompatModeDialog(
1713                                        ActivityManagerService.this, mContext,
1714                                        ar.info.applicationInfo);
1715                                mCompatModeDialog.show();
1716                            }
1717                        }
1718                    }
1719                }
1720                break;
1721            }
1722            case SHOW_UNSUPPORTED_DISPLAY_SIZE_DIALOG_MSG: {
1723                synchronized (ActivityManagerService.this) {
1724                    final ActivityRecord ar = (ActivityRecord) msg.obj;
1725                    if (mUnsupportedDisplaySizeDialog != null) {
1726                        mUnsupportedDisplaySizeDialog.dismiss();
1727                        mUnsupportedDisplaySizeDialog = null;
1728                    }
1729                    if (ar != null && mCompatModePackages.getPackageNotifyUnsupportedZoomLocked(
1730                            ar.packageName)) {
1731                        mUnsupportedDisplaySizeDialog = new UnsupportedDisplaySizeDialog(
1732                                ActivityManagerService.this, mContext, ar.info.applicationInfo);
1733                        mUnsupportedDisplaySizeDialog.show();
1734                    }
1735                }
1736                break;
1737            }
1738            case START_USER_SWITCH_UI_MSG: {
1739                mUserController.showUserSwitchDialog((Pair<UserInfo, UserInfo>) msg.obj);
1740                break;
1741            }
1742            case DISMISS_DIALOG_UI_MSG: {
1743                final Dialog d = (Dialog) msg.obj;
1744                d.dismiss();
1745                break;
1746            }
1747            case DISPATCH_PROCESSES_CHANGED_UI_MSG: {
1748                dispatchProcessesChanged();
1749                break;
1750            }
1751            case DISPATCH_PROCESS_DIED_UI_MSG: {
1752                final int pid = msg.arg1;
1753                final int uid = msg.arg2;
1754                dispatchProcessDied(pid, uid);
1755                break;
1756            }
1757            case DISPATCH_UIDS_CHANGED_UI_MSG: {
1758                dispatchUidsChanged();
1759            } break;
1760            }
1761        }
1762    }
1763
1764    final class MainHandler extends Handler {
1765        public MainHandler(Looper looper) {
1766            super(looper, null, true);
1767        }
1768
1769        @Override
1770        public void handleMessage(Message msg) {
1771            switch (msg.what) {
1772            case UPDATE_CONFIGURATION_MSG: {
1773                final ContentResolver resolver = mContext.getContentResolver();
1774                Settings.System.putConfigurationForUser(resolver, (Configuration) msg.obj,
1775                        msg.arg1);
1776            } break;
1777            case GC_BACKGROUND_PROCESSES_MSG: {
1778                synchronized (ActivityManagerService.this) {
1779                    performAppGcsIfAppropriateLocked();
1780                }
1781            } break;
1782            case SERVICE_TIMEOUT_MSG: {
1783                if (mDidDexOpt) {
1784                    mDidDexOpt = false;
1785                    Message nmsg = mHandler.obtainMessage(SERVICE_TIMEOUT_MSG);
1786                    nmsg.obj = msg.obj;
1787                    mHandler.sendMessageDelayed(nmsg, ActiveServices.SERVICE_TIMEOUT);
1788                    return;
1789                }
1790                mServices.serviceTimeout((ProcessRecord)msg.obj);
1791            } break;
1792            case UPDATE_TIME_ZONE: {
1793                synchronized (ActivityManagerService.this) {
1794                    for (int i = mLruProcesses.size() - 1 ; i >= 0 ; i--) {
1795                        ProcessRecord r = mLruProcesses.get(i);
1796                        if (r.thread != null) {
1797                            try {
1798                                r.thread.updateTimeZone();
1799                            } catch (RemoteException ex) {
1800                                Slog.w(TAG, "Failed to update time zone for: " + r.info.processName);
1801                            }
1802                        }
1803                    }
1804                }
1805            } break;
1806            case CLEAR_DNS_CACHE_MSG: {
1807                synchronized (ActivityManagerService.this) {
1808                    for (int i = mLruProcesses.size() - 1 ; i >= 0 ; i--) {
1809                        ProcessRecord r = mLruProcesses.get(i);
1810                        if (r.thread != null) {
1811                            try {
1812                                r.thread.clearDnsCache();
1813                            } catch (RemoteException ex) {
1814                                Slog.w(TAG, "Failed to clear dns cache for: " + r.info.processName);
1815                            }
1816                        }
1817                    }
1818                }
1819            } break;
1820            case UPDATE_HTTP_PROXY_MSG: {
1821                ProxyInfo proxy = (ProxyInfo)msg.obj;
1822                String host = "";
1823                String port = "";
1824                String exclList = "";
1825                Uri pacFileUrl = Uri.EMPTY;
1826                if (proxy != null) {
1827                    host = proxy.getHost();
1828                    port = Integer.toString(proxy.getPort());
1829                    exclList = proxy.getExclusionListAsString();
1830                    pacFileUrl = proxy.getPacFileUrl();
1831                }
1832                synchronized (ActivityManagerService.this) {
1833                    for (int i = mLruProcesses.size() - 1 ; i >= 0 ; i--) {
1834                        ProcessRecord r = mLruProcesses.get(i);
1835                        if (r.thread != null) {
1836                            try {
1837                                r.thread.setHttpProxy(host, port, exclList, pacFileUrl);
1838                            } catch (RemoteException ex) {
1839                                Slog.w(TAG, "Failed to update http proxy for: " +
1840                                        r.info.processName);
1841                            }
1842                        }
1843                    }
1844                }
1845            } break;
1846            case PROC_START_TIMEOUT_MSG: {
1847                if (mDidDexOpt) {
1848                    mDidDexOpt = false;
1849                    Message nmsg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG);
1850                    nmsg.obj = msg.obj;
1851                    mHandler.sendMessageDelayed(nmsg, PROC_START_TIMEOUT);
1852                    return;
1853                }
1854                ProcessRecord app = (ProcessRecord)msg.obj;
1855                synchronized (ActivityManagerService.this) {
1856                    processStartTimedOutLocked(app);
1857                }
1858            } break;
1859            case CONTENT_PROVIDER_PUBLISH_TIMEOUT_MSG: {
1860                ProcessRecord app = (ProcessRecord)msg.obj;
1861                synchronized (ActivityManagerService.this) {
1862                    processContentProviderPublishTimedOutLocked(app);
1863                }
1864            } break;
1865            case DO_PENDING_ACTIVITY_LAUNCHES_MSG: {
1866                synchronized (ActivityManagerService.this) {
1867                    mActivityStarter.doPendingActivityLaunchesLocked(true);
1868                }
1869            } break;
1870            case KILL_APPLICATION_MSG: {
1871                synchronized (ActivityManagerService.this) {
1872                    final int appId = msg.arg1;
1873                    final int userId = msg.arg2;
1874                    Bundle bundle = (Bundle)msg.obj;
1875                    String pkg = bundle.getString("pkg");
1876                    String reason = bundle.getString("reason");
1877                    forceStopPackageLocked(pkg, appId, false, false, true, false,
1878                            false, userId, reason);
1879                }
1880            } break;
1881            case FINALIZE_PENDING_INTENT_MSG: {
1882                ((PendingIntentRecord)msg.obj).completeFinalize();
1883            } break;
1884            case POST_HEAVY_NOTIFICATION_MSG: {
1885                INotificationManager inm = NotificationManager.getService();
1886                if (inm == null) {
1887                    return;
1888                }
1889
1890                ActivityRecord root = (ActivityRecord)msg.obj;
1891                ProcessRecord process = root.app;
1892                if (process == null) {
1893                    return;
1894                }
1895
1896                try {
1897                    Context context = mContext.createPackageContext(process.info.packageName, 0);
1898                    String text = mContext.getString(R.string.heavy_weight_notification,
1899                            context.getApplicationInfo().loadLabel(context.getPackageManager()));
1900                    Notification notification = new Notification.Builder(context)
1901                            .setSmallIcon(com.android.internal.R.drawable.stat_sys_adb)
1902                            .setWhen(0)
1903                            .setOngoing(true)
1904                            .setTicker(text)
1905                            .setColor(mContext.getColor(
1906                                    com.android.internal.R.color.system_notification_accent_color))
1907                            .setContentTitle(text)
1908                            .setContentText(
1909                                    mContext.getText(R.string.heavy_weight_notification_detail))
1910                            .setContentIntent(PendingIntent.getActivityAsUser(mContext, 0,
1911                                    root.intent, PendingIntent.FLAG_CANCEL_CURRENT, null,
1912                                    new UserHandle(root.userId)))
1913                            .build();
1914                    try {
1915                        int[] outId = new int[1];
1916                        inm.enqueueNotificationWithTag("android", "android", null,
1917                                R.string.heavy_weight_notification,
1918                                notification, outId, root.userId);
1919                    } catch (RuntimeException e) {
1920                        Slog.w(ActivityManagerService.TAG,
1921                                "Error showing notification for heavy-weight app", e);
1922                    } catch (RemoteException e) {
1923                    }
1924                } catch (NameNotFoundException e) {
1925                    Slog.w(TAG, "Unable to create context for heavy notification", e);
1926                }
1927            } break;
1928            case CANCEL_HEAVY_NOTIFICATION_MSG: {
1929                INotificationManager inm = NotificationManager.getService();
1930                if (inm == null) {
1931                    return;
1932                }
1933                try {
1934                    inm.cancelNotificationWithTag("android", null,
1935                            R.string.heavy_weight_notification,  msg.arg1);
1936                } catch (RuntimeException e) {
1937                    Slog.w(ActivityManagerService.TAG,
1938                            "Error canceling notification for service", e);
1939                } catch (RemoteException e) {
1940                }
1941            } break;
1942            case CHECK_EXCESSIVE_WAKE_LOCKS_MSG: {
1943                synchronized (ActivityManagerService.this) {
1944                    checkExcessivePowerUsageLocked(true);
1945                    removeMessages(CHECK_EXCESSIVE_WAKE_LOCKS_MSG);
1946                    Message nmsg = obtainMessage(CHECK_EXCESSIVE_WAKE_LOCKS_MSG);
1947                    sendMessageDelayed(nmsg, POWER_CHECK_DELAY);
1948                }
1949            } break;
1950            case REPORT_MEM_USAGE_MSG: {
1951                final ArrayList<ProcessMemInfo> memInfos = (ArrayList<ProcessMemInfo>)msg.obj;
1952                Thread thread = new Thread() {
1953                    @Override public void run() {
1954                        reportMemUsage(memInfos);
1955                    }
1956                };
1957                thread.start();
1958                break;
1959            }
1960            case REPORT_USER_SWITCH_MSG: {
1961                mUserController.dispatchUserSwitch((UserState) msg.obj, msg.arg1, msg.arg2);
1962                break;
1963            }
1964            case CONTINUE_USER_SWITCH_MSG: {
1965                mUserController.continueUserSwitch((UserState) msg.obj, msg.arg1, msg.arg2);
1966                break;
1967            }
1968            case USER_SWITCH_TIMEOUT_MSG: {
1969                mUserController.timeoutUserSwitch((UserState) msg.obj, msg.arg1, msg.arg2);
1970                break;
1971            }
1972            case IMMERSIVE_MODE_LOCK_MSG: {
1973                final boolean nextState = (msg.arg1 != 0);
1974                if (mUpdateLock.isHeld() != nextState) {
1975                    if (DEBUG_IMMERSIVE) Slog.d(TAG_IMMERSIVE,
1976                            "Applying new update lock state '" + nextState
1977                            + "' for " + (ActivityRecord)msg.obj);
1978                    if (nextState) {
1979                        mUpdateLock.acquire();
1980                    } else {
1981                        mUpdateLock.release();
1982                    }
1983                }
1984                break;
1985            }
1986            case PERSIST_URI_GRANTS_MSG: {
1987                writeGrantedUriPermissions();
1988                break;
1989            }
1990            case REQUEST_ALL_PSS_MSG: {
1991                synchronized (ActivityManagerService.this) {
1992                    requestPssAllProcsLocked(SystemClock.uptimeMillis(), true, false);
1993                }
1994                break;
1995            }
1996            case START_PROFILES_MSG: {
1997                synchronized (ActivityManagerService.this) {
1998                    mUserController.startProfilesLocked();
1999                }
2000                break;
2001            }
2002            case UPDATE_TIME: {
2003                synchronized (ActivityManagerService.this) {
2004                    for (int i = mLruProcesses.size() - 1 ; i >= 0 ; i--) {
2005                        ProcessRecord r = mLruProcesses.get(i);
2006                        if (r.thread != null) {
2007                            try {
2008                                r.thread.updateTimePrefs(msg.arg1 == 0 ? false : true);
2009                            } catch (RemoteException ex) {
2010                                Slog.w(TAG, "Failed to update preferences for: " + r.info.processName);
2011                            }
2012                        }
2013                    }
2014                }
2015                break;
2016            }
2017            case SYSTEM_USER_START_MSG: {
2018                mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_RUNNING_START,
2019                        Integer.toString(msg.arg1), msg.arg1);
2020                mSystemServiceManager.startUser(msg.arg1);
2021                break;
2022            }
2023            case SYSTEM_USER_UNLOCK_MSG: {
2024                final int userId = msg.arg1;
2025                mSystemServiceManager.unlockUser(userId);
2026                synchronized (ActivityManagerService.this) {
2027                    mRecentTasks.loadUserRecentsLocked(userId);
2028                }
2029                if (userId == UserHandle.USER_SYSTEM) {
2030                    startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_UNAWARE);
2031                }
2032                installEncryptionUnawareProviders(userId);
2033                mUserController.finishUserUnlocked((UserState) msg.obj);
2034                break;
2035            }
2036            case SYSTEM_USER_CURRENT_MSG: {
2037                mBatteryStatsService.noteEvent(
2038                        BatteryStats.HistoryItem.EVENT_USER_FOREGROUND_FINISH,
2039                        Integer.toString(msg.arg2), msg.arg2);
2040                mBatteryStatsService.noteEvent(
2041                        BatteryStats.HistoryItem.EVENT_USER_FOREGROUND_START,
2042                        Integer.toString(msg.arg1), msg.arg1);
2043                mSystemServiceManager.switchUser(msg.arg1);
2044                break;
2045            }
2046            case ENTER_ANIMATION_COMPLETE_MSG: {
2047                synchronized (ActivityManagerService.this) {
2048                    ActivityRecord r = ActivityRecord.forTokenLocked((IBinder) msg.obj);
2049                    if (r != null && r.app != null && r.app.thread != null) {
2050                        try {
2051                            r.app.thread.scheduleEnterAnimationComplete(r.appToken);
2052                        } catch (RemoteException e) {
2053                        }
2054                    }
2055                }
2056                break;
2057            }
2058            case FINISH_BOOTING_MSG: {
2059                if (msg.arg1 != 0) {
2060                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "FinishBooting");
2061                    finishBooting();
2062                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
2063                }
2064                if (msg.arg2 != 0) {
2065                    enableScreenAfterBoot();
2066                }
2067                break;
2068            }
2069            case SEND_LOCALE_TO_MOUNT_DAEMON_MSG: {
2070                try {
2071                    Locale l = (Locale) msg.obj;
2072                    IBinder service = ServiceManager.getService("mount");
2073                    IMountService mountService = IMountService.Stub.asInterface(service);
2074                    Log.d(TAG, "Storing locale " + l.toLanguageTag() + " for decryption UI");
2075                    mountService.setField(StorageManager.SYSTEM_LOCALE_KEY, l.toLanguageTag());
2076                } catch (RemoteException e) {
2077                    Log.e(TAG, "Error storing locale for decryption UI", e);
2078                }
2079                break;
2080            }
2081            case NOTIFY_TASK_STACK_CHANGE_LISTENERS_MSG: {
2082                synchronized (ActivityManagerService.this) {
2083                    for (int i = mTaskStackListeners.beginBroadcast() - 1; i >= 0; i--) {
2084                        try {
2085                            // Make a one-way callback to the listener
2086                            mTaskStackListeners.getBroadcastItem(i).onTaskStackChanged();
2087                        } catch (RemoteException e){
2088                            // Handled by the RemoteCallbackList
2089                        }
2090                    }
2091                    mTaskStackListeners.finishBroadcast();
2092                }
2093                break;
2094            }
2095            case NOTIFY_ACTIVITY_PINNED_LISTENERS_MSG: {
2096                synchronized (ActivityManagerService.this) {
2097                    for (int i = mTaskStackListeners.beginBroadcast() - 1; i >= 0; i--) {
2098                        try {
2099                            // Make a one-way callback to the listener
2100                            mTaskStackListeners.getBroadcastItem(i).onActivityPinned();
2101                        } catch (RemoteException e){
2102                            // Handled by the RemoteCallbackList
2103                        }
2104                    }
2105                    mTaskStackListeners.finishBroadcast();
2106                }
2107                break;
2108            }
2109            case NOTIFY_PINNED_ACTIVITY_RESTART_ATTEMPT_LISTENERS_MSG: {
2110                synchronized (ActivityManagerService.this) {
2111                    for (int i = mTaskStackListeners.beginBroadcast() - 1; i >= 0; i--) {
2112                        try {
2113                            // Make a one-way callback to the listener
2114                            mTaskStackListeners.getBroadcastItem(i).onPinnedActivityRestartAttempt();
2115                        } catch (RemoteException e){
2116                            // Handled by the RemoteCallbackList
2117                        }
2118                    }
2119                    mTaskStackListeners.finishBroadcast();
2120                }
2121                break;
2122            }
2123            case NOTIFY_PINNED_STACK_ANIMATION_ENDED_LISTENERS_MSG: {
2124                synchronized (ActivityManagerService.this) {
2125                    for (int i = mTaskStackListeners.beginBroadcast() - 1; i >= 0; i--) {
2126                        try {
2127                            // Make a one-way callback to the listener
2128                            mTaskStackListeners.getBroadcastItem(i).onPinnedStackAnimationEnded();
2129                        } catch (RemoteException e){
2130                            // Handled by the RemoteCallbackList
2131                        }
2132                    }
2133                    mTaskStackListeners.finishBroadcast();
2134                }
2135                break;
2136            }
2137            case NOTIFY_FORCED_RESIZABLE_MSG: {
2138                synchronized (ActivityManagerService.this) {
2139                    for (int i = mTaskStackListeners.beginBroadcast() - 1; i >= 0; i--) {
2140                        try {
2141                            // Make a one-way callback to the listener
2142                            mTaskStackListeners.getBroadcastItem(i).onActivityForcedResizable(
2143                                    (String) msg.obj, msg.arg1);
2144                        } catch (RemoteException e){
2145                            // Handled by the RemoteCallbackList
2146                        }
2147                    }
2148                    mTaskStackListeners.finishBroadcast();
2149                }
2150                break;
2151            }
2152                case NOTIFY_ACTIVITY_DISMISSING_DOCKED_STACK_MSG: {
2153                    synchronized (ActivityManagerService.this) {
2154                        for (int i = mTaskStackListeners.beginBroadcast() - 1; i >= 0; i--) {
2155                            try {
2156                                // Make a one-way callback to the listener
2157                                mTaskStackListeners.getBroadcastItem(i)
2158                                        .onActivityDismissingDockedStack();
2159                            } catch (RemoteException e){
2160                                // Handled by the RemoteCallbackList
2161                            }
2162                        }
2163                        mTaskStackListeners.finishBroadcast();
2164                    }
2165                    break;
2166                }
2167            case NOTIFY_CLEARTEXT_NETWORK_MSG: {
2168                final int uid = msg.arg1;
2169                final byte[] firstPacket = (byte[]) msg.obj;
2170
2171                synchronized (mPidsSelfLocked) {
2172                    for (int i = 0; i < mPidsSelfLocked.size(); i++) {
2173                        final ProcessRecord p = mPidsSelfLocked.valueAt(i);
2174                        if (p.uid == uid) {
2175                            try {
2176                                p.thread.notifyCleartextNetwork(firstPacket);
2177                            } catch (RemoteException ignored) {
2178                            }
2179                        }
2180                    }
2181                }
2182                break;
2183            }
2184            case POST_DUMP_HEAP_NOTIFICATION_MSG: {
2185                final String procName;
2186                final int uid;
2187                final long memLimit;
2188                final String reportPackage;
2189                synchronized (ActivityManagerService.this) {
2190                    procName = mMemWatchDumpProcName;
2191                    uid = mMemWatchDumpUid;
2192                    Pair<Long, String> val = mMemWatchProcesses.get(procName, uid);
2193                    if (val == null) {
2194                        val = mMemWatchProcesses.get(procName, 0);
2195                    }
2196                    if (val != null) {
2197                        memLimit = val.first;
2198                        reportPackage = val.second;
2199                    } else {
2200                        memLimit = 0;
2201                        reportPackage = null;
2202                    }
2203                }
2204                if (procName == null) {
2205                    return;
2206                }
2207
2208                if (DEBUG_PSS) Slog.d(TAG_PSS,
2209                        "Showing dump heap notification from " + procName + "/" + uid);
2210
2211                INotificationManager inm = NotificationManager.getService();
2212                if (inm == null) {
2213                    return;
2214                }
2215
2216                String text = mContext.getString(R.string.dump_heap_notification, procName);
2217
2218
2219                Intent deleteIntent = new Intent();
2220                deleteIntent.setAction(DumpHeapActivity.ACTION_DELETE_DUMPHEAP);
2221                Intent intent = new Intent();
2222                intent.setClassName("android", DumpHeapActivity.class.getName());
2223                intent.putExtra(DumpHeapActivity.KEY_PROCESS, procName);
2224                intent.putExtra(DumpHeapActivity.KEY_SIZE, memLimit);
2225                if (reportPackage != null) {
2226                    intent.putExtra(DumpHeapActivity.KEY_DIRECT_LAUNCH, reportPackage);
2227                }
2228                int userId = UserHandle.getUserId(uid);
2229                Notification notification = new Notification.Builder(mContext)
2230                        .setSmallIcon(com.android.internal.R.drawable.stat_sys_adb)
2231                        .setWhen(0)
2232                        .setOngoing(true)
2233                        .setAutoCancel(true)
2234                        .setTicker(text)
2235                        .setColor(mContext.getColor(
2236                                com.android.internal.R.color.system_notification_accent_color))
2237                        .setContentTitle(text)
2238                        .setContentText(
2239                                mContext.getText(R.string.dump_heap_notification_detail))
2240                        .setContentIntent(PendingIntent.getActivityAsUser(mContext, 0,
2241                                intent, PendingIntent.FLAG_CANCEL_CURRENT, null,
2242                                new UserHandle(userId)))
2243                        .setDeleteIntent(PendingIntent.getBroadcastAsUser(mContext, 0,
2244                                deleteIntent, 0, UserHandle.SYSTEM))
2245                        .build();
2246
2247                try {
2248                    int[] outId = new int[1];
2249                    inm.enqueueNotificationWithTag("android", "android", null,
2250                            R.string.dump_heap_notification,
2251                            notification, outId, userId);
2252                } catch (RuntimeException e) {
2253                    Slog.w(ActivityManagerService.TAG,
2254                            "Error showing notification for dump heap", e);
2255                } catch (RemoteException e) {
2256                }
2257            } break;
2258            case DELETE_DUMPHEAP_MSG: {
2259                revokeUriPermission(ActivityThread.currentActivityThread().getApplicationThread(),
2260                        DumpHeapActivity.JAVA_URI,
2261                        Intent.FLAG_GRANT_READ_URI_PERMISSION
2262                                | Intent.FLAG_GRANT_WRITE_URI_PERMISSION,
2263                        UserHandle.myUserId());
2264                synchronized (ActivityManagerService.this) {
2265                    mMemWatchDumpFile = null;
2266                    mMemWatchDumpProcName = null;
2267                    mMemWatchDumpPid = -1;
2268                    mMemWatchDumpUid = -1;
2269                }
2270            } break;
2271            case FOREGROUND_PROFILE_CHANGED_MSG: {
2272                mUserController.dispatchForegroundProfileChanged(msg.arg1);
2273            } break;
2274            case REPORT_TIME_TRACKER_MSG: {
2275                AppTimeTracker tracker = (AppTimeTracker)msg.obj;
2276                tracker.deliverResult(mContext);
2277            } break;
2278            case REPORT_USER_SWITCH_COMPLETE_MSG: {
2279                mUserController.dispatchUserSwitchComplete(msg.arg1);
2280            } break;
2281            case SHUTDOWN_UI_AUTOMATION_CONNECTION_MSG: {
2282                IUiAutomationConnection connection = (IUiAutomationConnection) msg.obj;
2283                try {
2284                    connection.shutdown();
2285                } catch (RemoteException e) {
2286                    Slog.w(TAG, "Error shutting down UiAutomationConnection");
2287                }
2288                // Only a UiAutomation can set this flag and now that
2289                // it is finished we make sure it is reset to its default.
2290                mUserIsMonkey = false;
2291            } break;
2292            case APP_BOOST_DEACTIVATE_MSG: {
2293                synchronized(ActivityManagerService.this) {
2294                    if (mIsBoosted) {
2295                        if (mBoostStartTime < (SystemClock.uptimeMillis() - APP_BOOST_TIMEOUT)) {
2296                            nativeMigrateFromBoost();
2297                            mIsBoosted = false;
2298                            mBoostStartTime = 0;
2299                        } else {
2300                            Message newmsg = mHandler.obtainMessage(APP_BOOST_DEACTIVATE_MSG);
2301                            mHandler.sendMessageDelayed(newmsg, APP_BOOST_TIMEOUT);
2302                        }
2303                    }
2304                }
2305            } break;
2306            case IDLE_UIDS_MSG: {
2307                idleUids();
2308            } break;
2309            case LOG_STACK_STATE: {
2310                synchronized (ActivityManagerService.this) {
2311                    mStackSupervisor.logStackState();
2312                }
2313            } break;
2314            case VR_MODE_CHANGE_MSG: {
2315                VrManagerInternal vrService = LocalServices.getService(VrManagerInternal.class);
2316                final ActivityRecord r = (ActivityRecord) msg.obj;
2317                boolean vrMode;
2318                ComponentName requestedPackage;
2319                ComponentName callingPackage;
2320                int userId;
2321                synchronized (ActivityManagerService.this) {
2322                    vrMode = r.requestedVrComponent != null;
2323                    requestedPackage = r.requestedVrComponent;
2324                    userId = r.userId;
2325                    callingPackage = r.info.getComponentName();
2326                    if (mInVrMode != vrMode) {
2327                        mInVrMode = vrMode;
2328                        mShowDialogs = shouldShowDialogs(mConfiguration, mInVrMode);
2329                        if (r.app != null) {
2330                            ProcessRecord proc = r.app;
2331                            if (proc.vrThreadTid > 0) {
2332                                if (proc.curSchedGroup == ProcessList.SCHED_GROUP_TOP_APP) {
2333                                    try {
2334                                        if (mInVrMode == true) {
2335                                            Process.setThreadScheduler(proc.vrThreadTid,
2336                                                Process.SCHED_FIFO | Process.SCHED_RESET_ON_FORK, 1);
2337                                        } else {
2338                                            Process.setThreadScheduler(proc.vrThreadTid,
2339                                                Process.SCHED_OTHER, 0);
2340                                        }
2341                                    } catch (IllegalArgumentException e) {
2342                                        Slog.w(TAG, "Failed to set scheduling policy, thread does"
2343                                                + " not exist:\n" + e);
2344                                    }
2345                                }
2346                            }
2347                        }
2348                    }
2349                }
2350                vrService.setVrMode(vrMode, requestedPackage, userId, callingPackage);
2351            } break;
2352            case VR_MODE_APPLY_IF_NEEDED_MSG: {
2353                final ActivityRecord r = (ActivityRecord) msg.obj;
2354                final boolean needsVrMode = r != null && r.requestedVrComponent != null;
2355                if (needsVrMode) {
2356                    applyVrMode(msg.arg1 == 1, r.requestedVrComponent, r.userId,
2357                            r.info.getComponentName(), false);
2358                }
2359            } break;
2360            }
2361        }
2362    };
2363
2364    static final int COLLECT_PSS_BG_MSG = 1;
2365
2366    final Handler mBgHandler = new Handler(BackgroundThread.getHandler().getLooper()) {
2367        @Override
2368        public void handleMessage(Message msg) {
2369            switch (msg.what) {
2370            case COLLECT_PSS_BG_MSG: {
2371                long start = SystemClock.uptimeMillis();
2372                MemInfoReader memInfo = null;
2373                synchronized (ActivityManagerService.this) {
2374                    if (mFullPssPending) {
2375                        mFullPssPending = false;
2376                        memInfo = new MemInfoReader();
2377                    }
2378                }
2379                if (memInfo != null) {
2380                    updateCpuStatsNow();
2381                    long nativeTotalPss = 0;
2382                    final List<ProcessCpuTracker.Stats> stats;
2383                    synchronized (mProcessCpuTracker) {
2384                        stats = mProcessCpuTracker.getStats( (st)-> {
2385                            return st.vsize > 0 && st.uid < Process.FIRST_APPLICATION_UID;
2386                        });
2387                    }
2388                    final int N = stats.size();
2389                    for (int j = 0; j < N; j++) {
2390                        synchronized (mPidsSelfLocked) {
2391                            if (mPidsSelfLocked.indexOfKey(stats.get(j).pid) >= 0) {
2392                                // This is one of our own processes; skip it.
2393                                continue;
2394                            }
2395                        }
2396                        nativeTotalPss += Debug.getPss(stats.get(j).pid, null, null);
2397                    }
2398                    memInfo.readMemInfo();
2399                    synchronized (ActivityManagerService.this) {
2400                        if (DEBUG_PSS) Slog.d(TAG_PSS, "Collected native and kernel memory in "
2401                                + (SystemClock.uptimeMillis()-start) + "ms");
2402                        final long cachedKb = memInfo.getCachedSizeKb();
2403                        final long freeKb = memInfo.getFreeSizeKb();
2404                        final long zramKb = memInfo.getZramTotalSizeKb();
2405                        final long kernelKb = memInfo.getKernelUsedSizeKb();
2406                        EventLogTags.writeAmMeminfo(cachedKb*1024, freeKb*1024, zramKb*1024,
2407                                kernelKb*1024, nativeTotalPss*1024);
2408                        mProcessStats.addSysMemUsageLocked(cachedKb, freeKb, zramKb, kernelKb,
2409                                nativeTotalPss);
2410                    }
2411                }
2412
2413                int num = 0;
2414                long[] tmp = new long[2];
2415                do {
2416                    ProcessRecord proc;
2417                    int procState;
2418                    int pid;
2419                    long lastPssTime;
2420                    synchronized (ActivityManagerService.this) {
2421                        if (mPendingPssProcesses.size() <= 0) {
2422                            if (mTestPssMode || DEBUG_PSS) Slog.d(TAG_PSS,
2423                                    "Collected PSS of " + num + " processes in "
2424                                    + (SystemClock.uptimeMillis() - start) + "ms");
2425                            mPendingPssProcesses.clear();
2426                            return;
2427                        }
2428                        proc = mPendingPssProcesses.remove(0);
2429                        procState = proc.pssProcState;
2430                        lastPssTime = proc.lastPssTime;
2431                        if (proc.thread != null && procState == proc.setProcState
2432                                && (lastPssTime+ProcessList.PSS_SAFE_TIME_FROM_STATE_CHANGE)
2433                                        < SystemClock.uptimeMillis()) {
2434                            pid = proc.pid;
2435                        } else {
2436                            proc = null;
2437                            pid = 0;
2438                        }
2439                    }
2440                    if (proc != null) {
2441                        long pss = Debug.getPss(pid, tmp, null);
2442                        synchronized (ActivityManagerService.this) {
2443                            if (pss != 0 && proc.thread != null && proc.setProcState == procState
2444                                    && proc.pid == pid && proc.lastPssTime == lastPssTime) {
2445                                num++;
2446                                recordPssSampleLocked(proc, procState, pss, tmp[0], tmp[1],
2447                                        SystemClock.uptimeMillis());
2448                            }
2449                        }
2450                    }
2451                } while (true);
2452            }
2453            }
2454        }
2455    };
2456
2457    public void setSystemProcess() {
2458        try {
2459            ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);
2460            ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
2461            ServiceManager.addService("meminfo", new MemBinder(this));
2462            ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
2463            ServiceManager.addService("dbinfo", new DbBinder(this));
2464            if (MONITOR_CPU_USAGE) {
2465                ServiceManager.addService("cpuinfo", new CpuBinder(this));
2466            }
2467            ServiceManager.addService("permission", new PermissionController(this));
2468            ServiceManager.addService("processinfo", new ProcessInfoService(this));
2469
2470            ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
2471                    "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
2472            mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
2473
2474            synchronized (this) {
2475                ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0);
2476                app.persistent = true;
2477                app.pid = MY_PID;
2478                app.maxAdj = ProcessList.SYSTEM_ADJ;
2479                app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
2480                synchronized (mPidsSelfLocked) {
2481                    mPidsSelfLocked.put(app.pid, app);
2482                }
2483                updateLruProcessLocked(app, false, null);
2484                updateOomAdjLocked();
2485            }
2486        } catch (PackageManager.NameNotFoundException e) {
2487            throw new RuntimeException(
2488                    "Unable to find android system package", e);
2489        }
2490    }
2491
2492    public void setWindowManager(WindowManagerService wm) {
2493        mWindowManager = wm;
2494        mStackSupervisor.setWindowManager(wm);
2495        mActivityStarter.setWindowManager(wm);
2496    }
2497
2498    public void setUsageStatsManager(UsageStatsManagerInternal usageStatsManager) {
2499        mUsageStatsService = usageStatsManager;
2500    }
2501
2502    public void startObservingNativeCrashes() {
2503        final NativeCrashListener ncl = new NativeCrashListener(this);
2504        ncl.start();
2505    }
2506
2507    public IAppOpsService getAppOpsService() {
2508        return mAppOpsService;
2509    }
2510
2511    static class MemBinder extends Binder {
2512        ActivityManagerService mActivityManagerService;
2513        MemBinder(ActivityManagerService activityManagerService) {
2514            mActivityManagerService = activityManagerService;
2515        }
2516
2517        @Override
2518        protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
2519            if (mActivityManagerService.checkCallingPermission(android.Manifest.permission.DUMP)
2520                    != PackageManager.PERMISSION_GRANTED) {
2521                pw.println("Permission Denial: can't dump meminfo from from pid="
2522                        + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid()
2523                        + " without permission " + android.Manifest.permission.DUMP);
2524                return;
2525            }
2526
2527            mActivityManagerService.dumpApplicationMemoryUsage(fd, pw, "  ", args, false, null);
2528        }
2529    }
2530
2531    static class GraphicsBinder extends Binder {
2532        ActivityManagerService mActivityManagerService;
2533        GraphicsBinder(ActivityManagerService activityManagerService) {
2534            mActivityManagerService = activityManagerService;
2535        }
2536
2537        @Override
2538        protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
2539            if (mActivityManagerService.checkCallingPermission(android.Manifest.permission.DUMP)
2540                    != PackageManager.PERMISSION_GRANTED) {
2541                pw.println("Permission Denial: can't dump gfxinfo from from pid="
2542                        + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid()
2543                        + " without permission " + android.Manifest.permission.DUMP);
2544                return;
2545            }
2546
2547            mActivityManagerService.dumpGraphicsHardwareUsage(fd, pw, args);
2548        }
2549    }
2550
2551    static class DbBinder extends Binder {
2552        ActivityManagerService mActivityManagerService;
2553        DbBinder(ActivityManagerService activityManagerService) {
2554            mActivityManagerService = activityManagerService;
2555        }
2556
2557        @Override
2558        protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
2559            if (mActivityManagerService.checkCallingPermission(android.Manifest.permission.DUMP)
2560                    != PackageManager.PERMISSION_GRANTED) {
2561                pw.println("Permission Denial: can't dump dbinfo from from pid="
2562                        + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid()
2563                        + " without permission " + android.Manifest.permission.DUMP);
2564                return;
2565            }
2566
2567            mActivityManagerService.dumpDbInfo(fd, pw, args);
2568        }
2569    }
2570
2571    static class CpuBinder extends Binder {
2572        ActivityManagerService mActivityManagerService;
2573        CpuBinder(ActivityManagerService activityManagerService) {
2574            mActivityManagerService = activityManagerService;
2575        }
2576
2577        @Override
2578        protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
2579            if (mActivityManagerService.checkCallingPermission(android.Manifest.permission.DUMP)
2580                    != PackageManager.PERMISSION_GRANTED) {
2581                pw.println("Permission Denial: can't dump cpuinfo from from pid="
2582                        + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid()
2583                        + " without permission " + android.Manifest.permission.DUMP);
2584                return;
2585            }
2586
2587            synchronized (mActivityManagerService.mProcessCpuTracker) {
2588                pw.print(mActivityManagerService.mProcessCpuTracker.printCurrentLoad());
2589                pw.print(mActivityManagerService.mProcessCpuTracker.printCurrentState(
2590                        SystemClock.uptimeMillis()));
2591            }
2592        }
2593    }
2594
2595    public static final class Lifecycle extends SystemService {
2596        private final ActivityManagerService mService;
2597
2598        public Lifecycle(Context context) {
2599            super(context);
2600            mService = new ActivityManagerService(context);
2601        }
2602
2603        @Override
2604        public void onStart() {
2605            mService.start();
2606        }
2607
2608        public ActivityManagerService getService() {
2609            return mService;
2610        }
2611    }
2612
2613    // Note: This method is invoked on the main thread but may need to attach various
2614    // handlers to other threads.  So take care to be explicit about the looper.
2615    public ActivityManagerService(Context systemContext) {
2616        mContext = systemContext;
2617        mFactoryTest = FactoryTest.getMode();
2618        mSystemThread = ActivityThread.currentActivityThread();
2619
2620        Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
2621
2622        mHandlerThread = new ServiceThread(TAG,
2623                android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
2624        mHandlerThread.start();
2625        mHandler = new MainHandler(mHandlerThread.getLooper());
2626        mUiHandler = new UiHandler();
2627
2628        /* static; one-time init here */
2629        if (sKillHandler == null) {
2630            sKillThread = new ServiceThread(TAG + ":kill",
2631                    android.os.Process.THREAD_PRIORITY_BACKGROUND, true /* allowIo */);
2632            sKillThread.start();
2633            sKillHandler = new KillHandler(sKillThread.getLooper());
2634        }
2635
2636        mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
2637                "foreground", BROADCAST_FG_TIMEOUT, false);
2638        mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
2639                "background", BROADCAST_BG_TIMEOUT, true);
2640        mBroadcastQueues[0] = mFgBroadcastQueue;
2641        mBroadcastQueues[1] = mBgBroadcastQueue;
2642
2643        mServices = new ActiveServices(this);
2644        mProviderMap = new ProviderMap(this);
2645        mAppErrors = new AppErrors(mContext, this);
2646
2647        // TODO: Move creation of battery stats service outside of activity manager service.
2648        File dataDir = Environment.getDataDirectory();
2649        File systemDir = new File(dataDir, "system");
2650        systemDir.mkdirs();
2651        mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
2652        mBatteryStatsService.getActiveStatistics().readLocked();
2653        mBatteryStatsService.scheduleWriteToDisk();
2654        mOnBattery = DEBUG_POWER ? true
2655                : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
2656        mBatteryStatsService.getActiveStatistics().setCallback(this);
2657
2658        mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
2659
2660        mAppOpsService = new AppOpsService(new File(systemDir, "appops.xml"), mHandler);
2661        mAppOpsService.startWatchingMode(AppOpsManager.OP_RUN_IN_BACKGROUND, null,
2662                new IAppOpsCallback.Stub() {
2663                    @Override public void opChanged(int op, int uid, String packageName) {
2664                        if (op == AppOpsManager.OP_RUN_IN_BACKGROUND && packageName != null) {
2665                            if (mAppOpsService.checkOperation(op, uid, packageName)
2666                                    != AppOpsManager.MODE_ALLOWED) {
2667                                runInBackgroundDisabled(uid);
2668                            }
2669                        }
2670                    }
2671                });
2672
2673        mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml"));
2674
2675        mUserController = new UserController(this);
2676
2677        GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",
2678            ConfigurationInfo.GL_ES_VERSION_UNDEFINED);
2679
2680        if (SystemProperties.getInt("sys.use_fifo_ui", 0) != 0) {
2681            mUseFifoUiScheduling = true;
2682        }
2683
2684        mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
2685
2686        mConfiguration.setToDefaults();
2687        mConfiguration.setLocales(LocaleList.getDefault());
2688
2689        mConfigurationSeq = mConfiguration.seq = 1;
2690        mProcessCpuTracker.init();
2691
2692        mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
2693        mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
2694        mStackSupervisor = new ActivityStackSupervisor(this);
2695        mActivityStarter = new ActivityStarter(this, mStackSupervisor);
2696        mRecentTasks = new RecentTasks(this, mStackSupervisor);
2697
2698        mProcessCpuThread = new Thread("CpuTracker") {
2699            @Override
2700            public void run() {
2701                while (true) {
2702                    try {
2703                        try {
2704                            synchronized(this) {
2705                                final long now = SystemClock.uptimeMillis();
2706                                long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
2707                                long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
2708                                //Slog.i(TAG, "Cpu delay=" + nextCpuDelay
2709                                //        + ", write delay=" + nextWriteDelay);
2710                                if (nextWriteDelay < nextCpuDelay) {
2711                                    nextCpuDelay = nextWriteDelay;
2712                                }
2713                                if (nextCpuDelay > 0) {
2714                                    mProcessCpuMutexFree.set(true);
2715                                    this.wait(nextCpuDelay);
2716                                }
2717                            }
2718                        } catch (InterruptedException e) {
2719                        }
2720                        updateCpuStatsNow();
2721                    } catch (Exception e) {
2722                        Slog.e(TAG, "Unexpected exception collecting process stats", e);
2723                    }
2724                }
2725            }
2726        };
2727
2728        Watchdog.getInstance().addMonitor(this);
2729        Watchdog.getInstance().addThread(mHandler);
2730    }
2731
2732    public void setSystemServiceManager(SystemServiceManager mgr) {
2733        mSystemServiceManager = mgr;
2734    }
2735
2736    public void setInstaller(Installer installer) {
2737        mInstaller = installer;
2738    }
2739
2740    private void start() {
2741        Process.removeAllProcessGroups();
2742        mProcessCpuThread.start();
2743
2744        mBatteryStatsService.publish(mContext);
2745        mAppOpsService.publish(mContext);
2746        Slog.d("AppOps", "AppOpsService published");
2747        LocalServices.addService(ActivityManagerInternal.class, new LocalService());
2748    }
2749
2750    void onUserStoppedLocked(int userId) {
2751        mRecentTasks.unloadUserDataFromMemoryLocked(userId);
2752    }
2753
2754    public void initPowerManagement() {
2755        mStackSupervisor.initPowerManagement();
2756        mBatteryStatsService.initPowerManagement();
2757        mLocalPowerManager = LocalServices.getService(PowerManagerInternal.class);
2758        PowerManager pm = (PowerManager)mContext.getSystemService(Context.POWER_SERVICE);
2759        mVoiceWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "*voice*");
2760        mVoiceWakeLock.setReferenceCounted(false);
2761    }
2762
2763    @Override
2764    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
2765            throws RemoteException {
2766        if (code == SYSPROPS_TRANSACTION) {
2767            // We need to tell all apps about the system property change.
2768            ArrayList<IBinder> procs = new ArrayList<IBinder>();
2769            synchronized(this) {
2770                final int NP = mProcessNames.getMap().size();
2771                for (int ip=0; ip<NP; ip++) {
2772                    SparseArray<ProcessRecord> apps = mProcessNames.getMap().valueAt(ip);
2773                    final int NA = apps.size();
2774                    for (int ia=0; ia<NA; ia++) {
2775                        ProcessRecord app = apps.valueAt(ia);
2776                        if (app.thread != null) {
2777                            procs.add(app.thread.asBinder());
2778                        }
2779                    }
2780                }
2781            }
2782
2783            int N = procs.size();
2784            for (int i=0; i<N; i++) {
2785                Parcel data2 = Parcel.obtain();
2786                try {
2787                    procs.get(i).transact(IBinder.SYSPROPS_TRANSACTION, data2, null, 0);
2788                } catch (RemoteException e) {
2789                }
2790                data2.recycle();
2791            }
2792        }
2793        try {
2794            return super.onTransact(code, data, reply, flags);
2795        } catch (RuntimeException e) {
2796            // The activity manager only throws security exceptions, so let's
2797            // log all others.
2798            if (!(e instanceof SecurityException)) {
2799                Slog.wtf(TAG, "Activity Manager Crash", e);
2800            }
2801            throw e;
2802        }
2803    }
2804
2805    void updateCpuStats() {
2806        final long now = SystemClock.uptimeMillis();
2807        if (mLastCpuTime.get() >= now - MONITOR_CPU_MIN_TIME) {
2808            return;
2809        }
2810        if (mProcessCpuMutexFree.compareAndSet(true, false)) {
2811            synchronized (mProcessCpuThread) {
2812                mProcessCpuThread.notify();
2813            }
2814        }
2815    }
2816
2817    void updateCpuStatsNow() {
2818        synchronized (mProcessCpuTracker) {
2819            mProcessCpuMutexFree.set(false);
2820            final long now = SystemClock.uptimeMillis();
2821            boolean haveNewCpuStats = false;
2822
2823            if (MONITOR_CPU_USAGE &&
2824                    mLastCpuTime.get() < (now-MONITOR_CPU_MIN_TIME)) {
2825                mLastCpuTime.set(now);
2826                mProcessCpuTracker.update();
2827                if (mProcessCpuTracker.hasGoodLastStats()) {
2828                    haveNewCpuStats = true;
2829                    //Slog.i(TAG, mProcessCpu.printCurrentState());
2830                    //Slog.i(TAG, "Total CPU usage: "
2831                    //        + mProcessCpu.getTotalCpuPercent() + "%");
2832
2833                    // Slog the cpu usage if the property is set.
2834                    if ("true".equals(SystemProperties.get("events.cpu"))) {
2835                        int user = mProcessCpuTracker.getLastUserTime();
2836                        int system = mProcessCpuTracker.getLastSystemTime();
2837                        int iowait = mProcessCpuTracker.getLastIoWaitTime();
2838                        int irq = mProcessCpuTracker.getLastIrqTime();
2839                        int softIrq = mProcessCpuTracker.getLastSoftIrqTime();
2840                        int idle = mProcessCpuTracker.getLastIdleTime();
2841
2842                        int total = user + system + iowait + irq + softIrq + idle;
2843                        if (total == 0) total = 1;
2844
2845                        EventLog.writeEvent(EventLogTags.CPU,
2846                                ((user+system+iowait+irq+softIrq) * 100) / total,
2847                                (user * 100) / total,
2848                                (system * 100) / total,
2849                                (iowait * 100) / total,
2850                                (irq * 100) / total,
2851                                (softIrq * 100) / total);
2852                    }
2853                }
2854            }
2855
2856            final BatteryStatsImpl bstats = mBatteryStatsService.getActiveStatistics();
2857            synchronized(bstats) {
2858                synchronized(mPidsSelfLocked) {
2859                    if (haveNewCpuStats) {
2860                        if (bstats.startAddingCpuLocked()) {
2861                            int totalUTime = 0;
2862                            int totalSTime = 0;
2863                            final int N = mProcessCpuTracker.countStats();
2864                            for (int i=0; i<N; i++) {
2865                                ProcessCpuTracker.Stats st = mProcessCpuTracker.getStats(i);
2866                                if (!st.working) {
2867                                    continue;
2868                                }
2869                                ProcessRecord pr = mPidsSelfLocked.get(st.pid);
2870                                totalUTime += st.rel_utime;
2871                                totalSTime += st.rel_stime;
2872                                if (pr != null) {
2873                                    BatteryStatsImpl.Uid.Proc ps = pr.curProcBatteryStats;
2874                                    if (ps == null || !ps.isActive()) {
2875                                        pr.curProcBatteryStats = ps = bstats.getProcessStatsLocked(
2876                                                pr.info.uid, pr.processName);
2877                                    }
2878                                    ps.addCpuTimeLocked(st.rel_utime, st.rel_stime);
2879                                    pr.curCpuTime += st.rel_utime + st.rel_stime;
2880                                } else {
2881                                    BatteryStatsImpl.Uid.Proc ps = st.batteryStats;
2882                                    if (ps == null || !ps.isActive()) {
2883                                        st.batteryStats = ps = bstats.getProcessStatsLocked(
2884                                                bstats.mapUid(st.uid), st.name);
2885                                    }
2886                                    ps.addCpuTimeLocked(st.rel_utime, st.rel_stime);
2887                                }
2888                            }
2889                            final int userTime = mProcessCpuTracker.getLastUserTime();
2890                            final int systemTime = mProcessCpuTracker.getLastSystemTime();
2891                            final int iowaitTime = mProcessCpuTracker.getLastIoWaitTime();
2892                            final int irqTime = mProcessCpuTracker.getLastIrqTime();
2893                            final int softIrqTime = mProcessCpuTracker.getLastSoftIrqTime();
2894                            final int idleTime = mProcessCpuTracker.getLastIdleTime();
2895                            bstats.finishAddingCpuLocked(totalUTime, totalSTime, userTime,
2896                                    systemTime, iowaitTime, irqTime, softIrqTime, idleTime);
2897                        }
2898                    }
2899                }
2900
2901                if (mLastWriteTime < (now-BATTERY_STATS_TIME)) {
2902                    mLastWriteTime = now;
2903                    mBatteryStatsService.scheduleWriteToDisk();
2904                }
2905            }
2906        }
2907    }
2908
2909    @Override
2910    public void batteryNeedsCpuUpdate() {
2911        updateCpuStatsNow();
2912    }
2913
2914    @Override
2915    public void batteryPowerChanged(boolean onBattery) {
2916        // When plugging in, update the CPU stats first before changing
2917        // the plug state.
2918        updateCpuStatsNow();
2919        synchronized (this) {
2920            synchronized(mPidsSelfLocked) {
2921                mOnBattery = DEBUG_POWER ? true : onBattery;
2922            }
2923        }
2924    }
2925
2926    @Override
2927    public void batterySendBroadcast(Intent intent) {
2928        broadcastIntentLocked(null, null, intent, null, null, 0, null, null, null,
2929                AppOpsManager.OP_NONE, null, false, false,
2930                -1, Process.SYSTEM_UID, UserHandle.USER_ALL);
2931    }
2932
2933    /**
2934     * Initialize the application bind args. These are passed to each
2935     * process when the bindApplication() IPC is sent to the process. They're
2936     * lazily setup to make sure the services are running when they're asked for.
2937     */
2938    private HashMap<String, IBinder> getCommonServicesLocked(boolean isolated) {
2939        // Isolated processes won't get this optimization, so that we don't
2940        // violate the rules about which services they have access to.
2941        if (isolated) {
2942            if (mIsolatedAppBindArgs == null) {
2943                mIsolatedAppBindArgs = new HashMap<>();
2944                mIsolatedAppBindArgs.put("package", ServiceManager.getService("package"));
2945            }
2946            return mIsolatedAppBindArgs;
2947        }
2948
2949        if (mAppBindArgs == null) {
2950            mAppBindArgs = new HashMap<>();
2951
2952            // Setup the application init args
2953            mAppBindArgs.put("package", ServiceManager.getService("package"));
2954            mAppBindArgs.put("window", ServiceManager.getService("window"));
2955            mAppBindArgs.put(Context.ALARM_SERVICE,
2956                    ServiceManager.getService(Context.ALARM_SERVICE));
2957        }
2958        return mAppBindArgs;
2959    }
2960
2961    boolean setFocusedActivityLocked(ActivityRecord r, String reason) {
2962        if (r == null || mFocusedActivity == r) {
2963            return false;
2964        }
2965
2966        if (!r.isFocusable()) {
2967            if (DEBUG_FOCUS) Slog.d(TAG_FOCUS, "setFocusedActivityLocked: unfocusable r=" + r);
2968            return false;
2969        }
2970
2971        if (DEBUG_FOCUS) Slog.d(TAG_FOCUS, "setFocusedActivityLocked: r=" + r);
2972
2973        final boolean wasDoingSetFocusedActivity = mDoingSetFocusedActivity;
2974        if (wasDoingSetFocusedActivity) Slog.w(TAG,
2975                "setFocusedActivityLocked: called recursively, r=" + r + ", reason=" + reason);
2976        mDoingSetFocusedActivity = true;
2977
2978        final ActivityRecord last = mFocusedActivity;
2979        mFocusedActivity = r;
2980        if (r.task.isApplicationTask()) {
2981            if (mCurAppTimeTracker != r.appTimeTracker) {
2982                // We are switching app tracking.  Complete the current one.
2983                if (mCurAppTimeTracker != null) {
2984                    mCurAppTimeTracker.stop();
2985                    mHandler.obtainMessage(
2986                            REPORT_TIME_TRACKER_MSG, mCurAppTimeTracker).sendToTarget();
2987                    mStackSupervisor.clearOtherAppTimeTrackers(r.appTimeTracker);
2988                    mCurAppTimeTracker = null;
2989                }
2990                if (r.appTimeTracker != null) {
2991                    mCurAppTimeTracker = r.appTimeTracker;
2992                    startTimeTrackingFocusedActivityLocked();
2993                }
2994            } else {
2995                startTimeTrackingFocusedActivityLocked();
2996            }
2997        } else {
2998            r.appTimeTracker = null;
2999        }
3000        // TODO: VI Maybe r.task.voiceInteractor || r.voiceInteractor != null
3001        // TODO: Probably not, because we don't want to resume voice on switching
3002        // back to this activity
3003        if (r.task.voiceInteractor != null) {
3004            startRunningVoiceLocked(r.task.voiceSession, r.info.applicationInfo.uid);
3005        } else {
3006            finishRunningVoiceLocked();
3007            IVoiceInteractionSession session;
3008            if (last != null && ((session = last.task.voiceSession) != null
3009                    || (session = last.voiceSession) != null)) {
3010                // We had been in a voice interaction session, but now focused has
3011                // move to something different.  Just finish the session, we can't
3012                // return to it and retain the proper state and synchronization with
3013                // the voice interaction service.
3014                finishVoiceTask(session);
3015            }
3016        }
3017        if (mStackSupervisor.moveActivityStackToFront(r, reason + " setFocusedActivity")) {
3018            mWindowManager.setFocusedApp(r.appToken, true);
3019        }
3020        applyUpdateLockStateLocked(r);
3021        applyUpdateVrModeLocked(r);
3022        if (mFocusedActivity.userId != mLastFocusedUserId) {
3023            mHandler.removeMessages(FOREGROUND_PROFILE_CHANGED_MSG);
3024            mHandler.obtainMessage(
3025                    FOREGROUND_PROFILE_CHANGED_MSG, mFocusedActivity.userId, 0).sendToTarget();
3026            mLastFocusedUserId = mFocusedActivity.userId;
3027        }
3028
3029        // Log a warning if the focused app is changed during the process. This could
3030        // indicate a problem of the focus setting logic!
3031        if (mFocusedActivity != r) Slog.w(TAG,
3032                "setFocusedActivityLocked: r=" + r + " but focused to " + mFocusedActivity);
3033        mDoingSetFocusedActivity = wasDoingSetFocusedActivity;
3034
3035        EventLogTags.writeAmFocusedActivity(
3036                mFocusedActivity == null ? -1 : mFocusedActivity.userId,
3037                mFocusedActivity == null ? "NULL" : mFocusedActivity.shortComponentName,
3038                reason);
3039        return true;
3040    }
3041
3042    final void resetFocusedActivityIfNeededLocked(ActivityRecord goingAway) {
3043        if (mFocusedActivity != goingAway) {
3044            return;
3045        }
3046
3047        final ActivityStack focusedStack = mStackSupervisor.getFocusedStack();
3048        if (focusedStack != null) {
3049            final ActivityRecord top = focusedStack.topActivity();
3050            if (top != null && top.userId != mLastFocusedUserId) {
3051                mHandler.removeMessages(FOREGROUND_PROFILE_CHANGED_MSG);
3052                mHandler.sendMessage(
3053                        mHandler.obtainMessage(FOREGROUND_PROFILE_CHANGED_MSG, top.userId, 0));
3054                mLastFocusedUserId = top.userId;
3055            }
3056        }
3057
3058        // Try to move focus to another activity if possible.
3059        if (setFocusedActivityLocked(
3060                focusedStack.topRunningActivityLocked(), "resetFocusedActivityIfNeeded")) {
3061            return;
3062        }
3063
3064        if (DEBUG_FOCUS) Slog.d(TAG_FOCUS, "resetFocusedActivityIfNeeded: Setting focus to NULL "
3065                + "prev mFocusedActivity=" + mFocusedActivity + " goingAway=" + goingAway);
3066        mFocusedActivity = null;
3067        EventLogTags.writeAmFocusedActivity(-1, "NULL", "resetFocusedActivityIfNeeded");
3068    }
3069
3070    @Override
3071    public void setFocusedStack(int stackId) {
3072        enforceCallingPermission(MANAGE_ACTIVITY_STACKS, "setFocusedStack()");
3073        if (DEBUG_FOCUS) Slog.d(TAG_FOCUS, "setFocusedStack: stackId=" + stackId);
3074        final long callingId = Binder.clearCallingIdentity();
3075        try {
3076            synchronized (this) {
3077                final ActivityStack stack = mStackSupervisor.getStack(stackId);
3078                if (stack == null) {
3079                    return;
3080                }
3081                final ActivityRecord r = stack.topRunningActivityLocked();
3082                if (setFocusedActivityLocked(r, "setFocusedStack")) {
3083                    mStackSupervisor.resumeFocusedStackTopActivityLocked();
3084                }
3085            }
3086        } finally {
3087            Binder.restoreCallingIdentity(callingId);
3088        }
3089    }
3090
3091    @Override
3092    public void setFocusedTask(int taskId) {
3093        enforceCallingPermission(MANAGE_ACTIVITY_STACKS, "setFocusedTask()");
3094        if (DEBUG_FOCUS) Slog.d(TAG_FOCUS, "setFocusedTask: taskId=" + taskId);
3095        final long callingId = Binder.clearCallingIdentity();
3096        try {
3097            synchronized (this) {
3098                final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId);
3099                if (task == null) {
3100                    return;
3101                }
3102                if (mUserController.shouldConfirmCredentials(task.userId)) {
3103                    mActivityStarter.showConfirmDeviceCredential(task.userId);
3104                    if (task.stack != null && task.stack.mStackId == FREEFORM_WORKSPACE_STACK_ID) {
3105                        mStackSupervisor.moveTaskToStackLocked(task.taskId,
3106                                FULLSCREEN_WORKSPACE_STACK_ID, !ON_TOP, !FORCE_FOCUS,
3107                                "setFocusedTask", ANIMATE);
3108                    }
3109                    return;
3110                }
3111                final ActivityRecord r = task.topRunningActivityLocked();
3112                if (setFocusedActivityLocked(r, "setFocusedTask")) {
3113                    mStackSupervisor.resumeFocusedStackTopActivityLocked();
3114                }
3115            }
3116        } finally {
3117            Binder.restoreCallingIdentity(callingId);
3118        }
3119    }
3120
3121    /** Sets the task stack listener that gets callbacks when a task stack changes. */
3122    @Override
3123    public void registerTaskStackListener(ITaskStackListener listener) throws RemoteException {
3124        enforceCallingPermission(MANAGE_ACTIVITY_STACKS, "registerTaskStackListener()");
3125        synchronized (this) {
3126            if (listener != null) {
3127                mTaskStackListeners.register(listener);
3128            }
3129        }
3130    }
3131
3132    @Override
3133    public void notifyActivityDrawn(IBinder token) {
3134        if (DEBUG_VISIBILITY) Slog.d(TAG_VISIBILITY, "notifyActivityDrawn: token=" + token);
3135        synchronized (this) {
3136            ActivityRecord r = mStackSupervisor.isInAnyStackLocked(token);
3137            if (r != null) {
3138                r.task.stack.notifyActivityDrawnLocked(r);
3139            }
3140        }
3141    }
3142
3143    final void applyUpdateLockStateLocked(ActivityRecord r) {
3144        // Modifications to the UpdateLock state are done on our handler, outside
3145        // the activity manager's locks.  The new state is determined based on the
3146        // state *now* of the relevant activity record.  The object is passed to
3147        // the handler solely for logging detail, not to be consulted/modified.
3148        final boolean nextState = r != null && r.immersive;
3149        mHandler.sendMessage(
3150                mHandler.obtainMessage(IMMERSIVE_MODE_LOCK_MSG, (nextState) ? 1 : 0, 0, r));
3151    }
3152
3153    final void applyUpdateVrModeLocked(ActivityRecord r) {
3154        mHandler.sendMessage(
3155                mHandler.obtainMessage(VR_MODE_CHANGE_MSG, 0, 0, r));
3156    }
3157
3158    private void applyVrModeIfNeededLocked(ActivityRecord r, boolean enable) {
3159        mHandler.sendMessage(
3160                mHandler.obtainMessage(VR_MODE_APPLY_IF_NEEDED_MSG, enable ? 1 : 0, 0, r));
3161    }
3162
3163    private void applyVrMode(boolean enabled, ComponentName packageName, int userId,
3164            ComponentName callingPackage, boolean immediate) {
3165        VrManagerInternal vrService =
3166                LocalServices.getService(VrManagerInternal.class);
3167        if (immediate) {
3168            vrService.setVrModeImmediate(enabled, packageName, userId, callingPackage);
3169        } else {
3170            vrService.setVrMode(enabled, packageName, userId, callingPackage);
3171        }
3172    }
3173
3174    final void showAskCompatModeDialogLocked(ActivityRecord r) {
3175        Message msg = Message.obtain();
3176        msg.what = SHOW_COMPAT_MODE_DIALOG_UI_MSG;
3177        msg.obj = r.task.askedCompatMode ? null : r;
3178        mUiHandler.sendMessage(msg);
3179    }
3180
3181    final void showUnsupportedZoomDialogIfNeededLocked(ActivityRecord r) {
3182        if (mConfiguration.densityDpi != DisplayMetrics.DENSITY_DEVICE_STABLE
3183                && r.appInfo.requiresSmallestWidthDp > mConfiguration.smallestScreenWidthDp) {
3184            final Message msg = Message.obtain();
3185            msg.what = SHOW_UNSUPPORTED_DISPLAY_SIZE_DIALOG_MSG;
3186            msg.obj = r;
3187            mUiHandler.sendMessage(msg);
3188        }
3189    }
3190
3191    private int updateLruProcessInternalLocked(ProcessRecord app, long now, int index,
3192            String what, Object obj, ProcessRecord srcApp) {
3193        app.lastActivityTime = now;
3194
3195        if (app.activities.size() > 0) {
3196            // Don't want to touch dependent processes that are hosting activities.
3197            return index;
3198        }
3199
3200        int lrui = mLruProcesses.lastIndexOf(app);
3201        if (lrui < 0) {
3202            Slog.wtf(TAG, "Adding dependent process " + app + " not on LRU list: "
3203                    + what + " " + obj + " from " + srcApp);
3204            return index;
3205        }
3206
3207        if (lrui >= index) {
3208            // Don't want to cause this to move dependent processes *back* in the
3209            // list as if they were less frequently used.
3210            return index;
3211        }
3212
3213        if (lrui >= mLruProcessActivityStart) {
3214            // Don't want to touch dependent processes that are hosting activities.
3215            return index;
3216        }
3217
3218        mLruProcesses.remove(lrui);
3219        if (index > 0) {
3220            index--;
3221        }
3222        if (DEBUG_LRU) Slog.d(TAG_LRU, "Moving dep from " + lrui + " to " + index
3223                + " in LRU list: " + app);
3224        mLruProcesses.add(index, app);
3225        return index;
3226    }
3227
3228    static void killProcessGroup(int uid, int pid) {
3229        if (sKillHandler != null) {
3230            sKillHandler.sendMessage(
3231                    sKillHandler.obtainMessage(KillHandler.KILL_PROCESS_GROUP_MSG, uid, pid));
3232        } else {
3233            Slog.w(TAG, "Asked to kill process group before system bringup!");
3234            Process.killProcessGroup(uid, pid);
3235        }
3236    }
3237
3238    final void removeLruProcessLocked(ProcessRecord app) {
3239        int lrui = mLruProcesses.lastIndexOf(app);
3240        if (lrui >= 0) {
3241            if (!app.killed) {
3242                Slog.wtfStack(TAG, "Removing process that hasn't been killed: " + app);
3243                Process.killProcessQuiet(app.pid);
3244                killProcessGroup(app.uid, app.pid);
3245            }
3246            if (lrui <= mLruProcessActivityStart) {
3247                mLruProcessActivityStart--;
3248            }
3249            if (lrui <= mLruProcessServiceStart) {
3250                mLruProcessServiceStart--;
3251            }
3252            mLruProcesses.remove(lrui);
3253        }
3254    }
3255
3256    final void updateLruProcessLocked(ProcessRecord app, boolean activityChange,
3257            ProcessRecord client) {
3258        final boolean hasActivity = app.activities.size() > 0 || app.hasClientActivities
3259                || app.treatLikeActivity;
3260        final boolean hasService = false; // not impl yet. app.services.size() > 0;
3261        if (!activityChange && hasActivity) {
3262            // The process has activities, so we are only allowing activity-based adjustments
3263            // to move it.  It should be kept in the front of the list with other
3264            // processes that have activities, and we don't want those to change their
3265            // order except due to activity operations.
3266            return;
3267        }
3268
3269        mLruSeq++;
3270        final long now = SystemClock.uptimeMillis();
3271        app.lastActivityTime = now;
3272
3273        // First a quick reject: if the app is already at the position we will
3274        // put it, then there is nothing to do.
3275        if (hasActivity) {
3276            final int N = mLruProcesses.size();
3277            if (N > 0 && mLruProcesses.get(N-1) == app) {
3278                if (DEBUG_LRU) Slog.d(TAG_LRU, "Not moving, already top activity: " + app);
3279                return;
3280            }
3281        } else {
3282            if (mLruProcessServiceStart > 0
3283                    && mLruProcesses.get(mLruProcessServiceStart-1) == app) {
3284                if (DEBUG_LRU) Slog.d(TAG_LRU, "Not moving, already top other: " + app);
3285                return;
3286            }
3287        }
3288
3289        int lrui = mLruProcesses.lastIndexOf(app);
3290
3291        if (app.persistent && lrui >= 0) {
3292            // We don't care about the position of persistent processes, as long as
3293            // they are in the list.
3294            if (DEBUG_LRU) Slog.d(TAG_LRU, "Not moving, persistent: " + app);
3295            return;
3296        }
3297
3298        /* In progress: compute new position first, so we can avoid doing work
3299           if the process is not actually going to move.  Not yet working.
3300        int addIndex;
3301        int nextIndex;
3302        boolean inActivity = false, inService = false;
3303        if (hasActivity) {
3304            // Process has activities, put it at the very tipsy-top.
3305            addIndex = mLruProcesses.size();
3306            nextIndex = mLruProcessServiceStart;
3307            inActivity = true;
3308        } else if (hasService) {
3309            // Process has services, put it at the top of the service list.
3310            addIndex = mLruProcessActivityStart;
3311            nextIndex = mLruProcessServiceStart;
3312            inActivity = true;
3313            inService = true;
3314        } else  {
3315            // Process not otherwise of interest, it goes to the top of the non-service area.
3316            addIndex = mLruProcessServiceStart;
3317            if (client != null) {
3318                int clientIndex = mLruProcesses.lastIndexOf(client);
3319                if (clientIndex < 0) Slog.d(TAG, "Unknown client " + client + " when updating "
3320                        + app);
3321                if (clientIndex >= 0 && addIndex > clientIndex) {
3322                    addIndex = clientIndex;
3323                }
3324            }
3325            nextIndex = addIndex > 0 ? addIndex-1 : addIndex;
3326        }
3327
3328        Slog.d(TAG, "Update LRU at " + lrui + " to " + addIndex + " (act="
3329                + mLruProcessActivityStart + "): " + app);
3330        */
3331
3332        if (lrui >= 0) {
3333            if (lrui < mLruProcessActivityStart) {
3334                mLruProcessActivityStart--;
3335            }
3336            if (lrui < mLruProcessServiceStart) {
3337                mLruProcessServiceStart--;
3338            }
3339            /*
3340            if (addIndex > lrui) {
3341                addIndex--;
3342            }
3343            if (nextIndex > lrui) {
3344                nextIndex--;
3345            }
3346            */
3347            mLruProcesses.remove(lrui);
3348        }
3349
3350        /*
3351        mLruProcesses.add(addIndex, app);
3352        if (inActivity) {
3353            mLruProcessActivityStart++;
3354        }
3355        if (inService) {
3356            mLruProcessActivityStart++;
3357        }
3358        */
3359
3360        int nextIndex;
3361        if (hasActivity) {
3362            final int N = mLruProcesses.size();
3363            if (app.activities.size() == 0 && mLruProcessActivityStart < (N - 1)) {
3364                // Process doesn't have activities, but has clients with
3365                // activities...  move it up, but one below the top (the top
3366                // should always have a real activity).
3367                if (DEBUG_LRU) Slog.d(TAG_LRU,
3368                        "Adding to second-top of LRU activity list: " + app);
3369                mLruProcesses.add(N - 1, app);
3370                // To keep it from spamming the LRU list (by making a bunch of clients),
3371                // we will push down any other entries owned by the app.
3372                final int uid = app.info.uid;
3373                for (int i = N - 2; i > mLruProcessActivityStart; i--) {
3374                    ProcessRecord subProc = mLruProcesses.get(i);
3375                    if (subProc.info.uid == uid) {
3376                        // We want to push this one down the list.  If the process after
3377                        // it is for the same uid, however, don't do so, because we don't
3378                        // want them internally to be re-ordered.
3379                        if (mLruProcesses.get(i - 1).info.uid != uid) {
3380                            if (DEBUG_LRU) Slog.d(TAG_LRU,
3381                                    "Pushing uid " + uid + " swapping at " + i + ": "
3382                                    + mLruProcesses.get(i) + " : " + mLruProcesses.get(i - 1));
3383                            ProcessRecord tmp = mLruProcesses.get(i);
3384                            mLruProcesses.set(i, mLruProcesses.get(i - 1));
3385                            mLruProcesses.set(i - 1, tmp);
3386                            i--;
3387                        }
3388                    } else {
3389                        // A gap, we can stop here.
3390                        break;
3391                    }
3392                }
3393            } else {
3394                // Process has activities, put it at the very tipsy-top.
3395                if (DEBUG_LRU) Slog.d(TAG_LRU, "Adding to top of LRU activity list: " + app);
3396                mLruProcesses.add(app);
3397            }
3398            nextIndex = mLruProcessServiceStart;
3399        } else if (hasService) {
3400            // Process has services, put it at the top of the service list.
3401            if (DEBUG_LRU) Slog.d(TAG_LRU, "Adding to top of LRU service list: " + app);
3402            mLruProcesses.add(mLruProcessActivityStart, app);
3403            nextIndex = mLruProcessServiceStart;
3404            mLruProcessActivityStart++;
3405        } else  {
3406            // Process not otherwise of interest, it goes to the top of the non-service area.
3407            int index = mLruProcessServiceStart;
3408            if (client != null) {
3409                // If there is a client, don't allow the process to be moved up higher
3410                // in the list than that client.
3411                int clientIndex = mLruProcesses.lastIndexOf(client);
3412                if (DEBUG_LRU && clientIndex < 0) Slog.d(TAG_LRU, "Unknown client " + client
3413                        + " when updating " + app);
3414                if (clientIndex <= lrui) {
3415                    // Don't allow the client index restriction to push it down farther in the
3416                    // list than it already is.
3417                    clientIndex = lrui;
3418                }
3419                if (clientIndex >= 0 && index > clientIndex) {
3420                    index = clientIndex;
3421                }
3422            }
3423            if (DEBUG_LRU) Slog.d(TAG_LRU, "Adding at " + index + " of LRU list: " + app);
3424            mLruProcesses.add(index, app);
3425            nextIndex = index-1;
3426            mLruProcessActivityStart++;
3427            mLruProcessServiceStart++;
3428        }
3429
3430        // If the app is currently using a content provider or service,
3431        // bump those processes as well.
3432        for (int j=app.connections.size()-1; j>=0; j--) {
3433            ConnectionRecord cr = app.connections.valueAt(j);
3434            if (cr.binding != null && !cr.serviceDead && cr.binding.service != null
3435                    && cr.binding.service.app != null
3436                    && cr.binding.service.app.lruSeq != mLruSeq
3437                    && !cr.binding.service.app.persistent) {
3438                nextIndex = updateLruProcessInternalLocked(cr.binding.service.app, now, nextIndex,
3439                        "service connection", cr, app);
3440            }
3441        }
3442        for (int j=app.conProviders.size()-1; j>=0; j--) {
3443            ContentProviderRecord cpr = app.conProviders.get(j).provider;
3444            if (cpr.proc != null && cpr.proc.lruSeq != mLruSeq && !cpr.proc.persistent) {
3445                nextIndex = updateLruProcessInternalLocked(cpr.proc, now, nextIndex,
3446                        "provider reference", cpr, app);
3447            }
3448        }
3449    }
3450
3451    final ProcessRecord getProcessRecordLocked(String processName, int uid, boolean keepIfLarge) {
3452        if (uid == Process.SYSTEM_UID) {
3453            // The system gets to run in any process.  If there are multiple
3454            // processes with the same uid, just pick the first (this
3455            // should never happen).
3456            SparseArray<ProcessRecord> procs = mProcessNames.getMap().get(processName);
3457            if (procs == null) return null;
3458            final int procCount = procs.size();
3459            for (int i = 0; i < procCount; i++) {
3460                final int procUid = procs.keyAt(i);
3461                if (UserHandle.isApp(procUid) || !UserHandle.isSameUser(procUid, uid)) {
3462                    // Don't use an app process or different user process for system component.
3463                    continue;
3464                }
3465                return procs.valueAt(i);
3466            }
3467        }
3468        ProcessRecord proc = mProcessNames.get(processName, uid);
3469        if (false && proc != null && !keepIfLarge
3470                && proc.setProcState >= ActivityManager.PROCESS_STATE_CACHED_EMPTY
3471                && proc.lastCachedPss >= 4000) {
3472            // Turn this condition on to cause killing to happen regularly, for testing.
3473            if (proc.baseProcessTracker != null) {
3474                proc.baseProcessTracker.reportCachedKill(proc.pkgList, proc.lastCachedPss);
3475            }
3476            proc.kill(Long.toString(proc.lastCachedPss) + "k from cached", true);
3477        } else if (proc != null && !keepIfLarge
3478                && mLastMemoryLevel > ProcessStats.ADJ_MEM_FACTOR_NORMAL
3479                && proc.setProcState >= ActivityManager.PROCESS_STATE_CACHED_EMPTY) {
3480            if (DEBUG_PSS) Slog.d(TAG_PSS, "May not keep " + proc + ": pss=" + proc.lastCachedPss);
3481            if (proc.lastCachedPss >= mProcessList.getCachedRestoreThresholdKb()) {
3482                if (proc.baseProcessTracker != null) {
3483                    proc.baseProcessTracker.reportCachedKill(proc.pkgList, proc.lastCachedPss);
3484                }
3485                proc.kill(Long.toString(proc.lastCachedPss) + "k from cached", true);
3486            }
3487        }
3488        return proc;
3489    }
3490
3491    void notifyPackageUse(String packageName, int reason) {
3492        IPackageManager pm = AppGlobals.getPackageManager();
3493        try {
3494            pm.notifyPackageUse(packageName, reason);
3495        } catch (RemoteException e) {
3496        }
3497    }
3498
3499    boolean isNextTransitionForward() {
3500        int transit = mWindowManager.getPendingAppTransition();
3501        return transit == TRANSIT_ACTIVITY_OPEN
3502                || transit == TRANSIT_TASK_OPEN
3503                || transit == TRANSIT_TASK_TO_FRONT;
3504    }
3505
3506    int startIsolatedProcess(String entryPoint, String[] entryPointArgs,
3507            String processName, String abiOverride, int uid, Runnable crashHandler) {
3508        synchronized(this) {
3509            ApplicationInfo info = new ApplicationInfo();
3510            // In general the ApplicationInfo.uid isn't neccesarily equal to ProcessRecord.uid.
3511            // For isolated processes, the former contains the parent's uid and the latter the
3512            // actual uid of the isolated process.
3513            // In the special case introduced by this method (which is, starting an isolated
3514            // process directly from the SystemServer without an actual parent app process) the
3515            // closest thing to a parent's uid is SYSTEM_UID.
3516            // The only important thing here is to keep AI.uid != PR.uid, in order to trigger
3517            // the |isolated| logic in the ProcessRecord constructor.
3518            info.uid = Process.SYSTEM_UID;
3519            info.processName = processName;
3520            info.className = entryPoint;
3521            info.packageName = "android";
3522            ProcessRecord proc = startProcessLocked(processName, info /* info */,
3523                    false /* knownToBeDead */, 0 /* intentFlags */, ""  /* hostingType */,
3524                    null /* hostingName */, true /* allowWhileBooting */, true /* isolated */,
3525                    uid, true /* keepIfLarge */, abiOverride, entryPoint, entryPointArgs,
3526                    crashHandler);
3527            return proc != null ? proc.pid : 0;
3528        }
3529    }
3530
3531    final ProcessRecord startProcessLocked(String processName,
3532            ApplicationInfo info, boolean knownToBeDead, int intentFlags,
3533            String hostingType, ComponentName hostingName, boolean allowWhileBooting,
3534            boolean isolated, boolean keepIfLarge) {
3535        return startProcessLocked(processName, info, knownToBeDead, intentFlags, hostingType,
3536                hostingName, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
3537                null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
3538                null /* crashHandler */);
3539    }
3540
3541    final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
3542            boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName,
3543            boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge,
3544            String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) {
3545        long startTime = SystemClock.elapsedRealtime();
3546        ProcessRecord app;
3547        if (!isolated) {
3548            app = getProcessRecordLocked(processName, info.uid, keepIfLarge);
3549            checkTime(startTime, "startProcess: after getProcessRecord");
3550
3551            if ((intentFlags & Intent.FLAG_FROM_BACKGROUND) != 0) {
3552                // If we are in the background, then check to see if this process
3553                // is bad.  If so, we will just silently fail.
3554                if (mAppErrors.isBadProcessLocked(info)) {
3555                    if (DEBUG_PROCESSES) Slog.v(TAG, "Bad process: " + info.uid
3556                            + "/" + info.processName);
3557                    return null;
3558                }
3559            } else {
3560                // When the user is explicitly starting a process, then clear its
3561                // crash count so that we won't make it bad until they see at
3562                // least one crash dialog again, and make the process good again
3563                // if it had been bad.
3564                if (DEBUG_PROCESSES) Slog.v(TAG, "Clearing bad process: " + info.uid
3565                        + "/" + info.processName);
3566                mAppErrors.resetProcessCrashTimeLocked(info);
3567                if (mAppErrors.isBadProcessLocked(info)) {
3568                    EventLog.writeEvent(EventLogTags.AM_PROC_GOOD,
3569                            UserHandle.getUserId(info.uid), info.uid,
3570                            info.processName);
3571                    mAppErrors.clearBadProcessLocked(info);
3572                    if (app != null) {
3573                        app.bad = false;
3574                    }
3575                }
3576            }
3577        } else {
3578            // If this is an isolated process, it can't re-use an existing process.
3579            app = null;
3580        }
3581
3582        // app launch boost for big.little configurations
3583        // use cpusets to migrate freshly launched tasks to big cores
3584        nativeMigrateToBoost();
3585        mIsBoosted = true;
3586        mBoostStartTime = SystemClock.uptimeMillis();
3587        Message msg = mHandler.obtainMessage(APP_BOOST_DEACTIVATE_MSG);
3588        mHandler.sendMessageDelayed(msg, APP_BOOST_MESSAGE_DELAY);
3589
3590        // We don't have to do anything more if:
3591        // (1) There is an existing application record; and
3592        // (2) The caller doesn't think it is dead, OR there is no thread
3593        //     object attached to it so we know it couldn't have crashed; and
3594        // (3) There is a pid assigned to it, so it is either starting or
3595        //     already running.
3596        if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES, "startProcess: name=" + processName
3597                + " app=" + app + " knownToBeDead=" + knownToBeDead
3598                + " thread=" + (app != null ? app.thread : null)
3599                + " pid=" + (app != null ? app.pid : -1));
3600        if (app != null && app.pid > 0) {
3601            if ((!knownToBeDead && !app.killed) || app.thread == null) {
3602                // We already have the app running, or are waiting for it to
3603                // come up (we have a pid but not yet its thread), so keep it.
3604                if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES, "App already running: " + app);
3605                // If this is a new package in the process, add the package to the list
3606                app.addPackage(info.packageName, info.versionCode, mProcessStats);
3607                checkTime(startTime, "startProcess: done, added package to proc");
3608                return app;
3609            }
3610
3611            // An application record is attached to a previous process,
3612            // clean it up now.
3613            if (DEBUG_PROCESSES || DEBUG_CLEANUP) Slog.v(TAG_PROCESSES, "App died: " + app);
3614            checkTime(startTime, "startProcess: bad proc running, killing");
3615            killProcessGroup(app.uid, app.pid);
3616            handleAppDiedLocked(app, true, true);
3617            checkTime(startTime, "startProcess: done killing old proc");
3618        }
3619
3620        String hostingNameStr = hostingName != null
3621                ? hostingName.flattenToShortString() : null;
3622
3623        if (app == null) {
3624            checkTime(startTime, "startProcess: creating new process record");
3625            app = newProcessRecordLocked(info, processName, isolated, isolatedUid);
3626            if (app == null) {
3627                Slog.w(TAG, "Failed making new process record for "
3628                        + processName + "/" + info.uid + " isolated=" + isolated);
3629                return null;
3630            }
3631            app.crashHandler = crashHandler;
3632            checkTime(startTime, "startProcess: done creating new process record");
3633        } else {
3634            // If this is a new package in the process, add the package to the list
3635            app.addPackage(info.packageName, info.versionCode, mProcessStats);
3636            checkTime(startTime, "startProcess: added package to existing proc");
3637        }
3638
3639        // If the system is not ready yet, then hold off on starting this
3640        // process until it is.
3641        if (!mProcessesReady
3642                && !isAllowedWhileBooting(info)
3643                && !allowWhileBooting) {
3644            if (!mProcessesOnHold.contains(app)) {
3645                mProcessesOnHold.add(app);
3646            }
3647            if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES,
3648                    "System not ready, putting on hold: " + app);
3649            checkTime(startTime, "startProcess: returning with proc on hold");
3650            return app;
3651        }
3652
3653        checkTime(startTime, "startProcess: stepping in to startProcess");
3654        startProcessLocked(
3655                app, hostingType, hostingNameStr, abiOverride, entryPoint, entryPointArgs);
3656        checkTime(startTime, "startProcess: done starting proc!");
3657        return (app.pid != 0) ? app : null;
3658    }
3659
3660    boolean isAllowedWhileBooting(ApplicationInfo ai) {
3661        return (ai.flags&ApplicationInfo.FLAG_PERSISTENT) != 0;
3662    }
3663
3664    private final void startProcessLocked(ProcessRecord app,
3665            String hostingType, String hostingNameStr) {
3666        startProcessLocked(app, hostingType, hostingNameStr, null /* abiOverride */,
3667                null /* entryPoint */, null /* entryPointArgs */);
3668    }
3669
3670    private final void startProcessLocked(ProcessRecord app, String hostingType,
3671            String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {
3672        long startTime = SystemClock.elapsedRealtime();
3673        if (app.pid > 0 && app.pid != MY_PID) {
3674            checkTime(startTime, "startProcess: removing from pids map");
3675            synchronized (mPidsSelfLocked) {
3676                mPidsSelfLocked.remove(app.pid);
3677                mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
3678            }
3679            checkTime(startTime, "startProcess: done removing from pids map");
3680            app.setPid(0);
3681        }
3682
3683        if (DEBUG_PROCESSES && mProcessesOnHold.contains(app)) Slog.v(TAG_PROCESSES,
3684                "startProcessLocked removing on hold: " + app);
3685        mProcessesOnHold.remove(app);
3686
3687        checkTime(startTime, "startProcess: starting to update cpu stats");
3688        updateCpuStats();
3689        checkTime(startTime, "startProcess: done updating cpu stats");
3690
3691        try {
3692            try {
3693                final int userId = UserHandle.getUserId(app.uid);
3694                AppGlobals.getPackageManager().checkPackageStartable(app.info.packageName, userId);
3695            } catch (RemoteException e) {
3696                throw e.rethrowAsRuntimeException();
3697            }
3698
3699            int uid = app.uid;
3700            int[] gids = null;
3701            int mountExternal = Zygote.MOUNT_EXTERNAL_NONE;
3702            if (!app.isolated) {
3703                int[] permGids = null;
3704                try {
3705                    checkTime(startTime, "startProcess: getting gids from package manager");
3706                    final IPackageManager pm = AppGlobals.getPackageManager();
3707                    permGids = pm.getPackageGids(app.info.packageName,
3708                            MATCH_DEBUG_TRIAGED_MISSING, app.userId);
3709                    MountServiceInternal mountServiceInternal = LocalServices.getService(
3710                            MountServiceInternal.class);
3711                    mountExternal = mountServiceInternal.getExternalStorageMountMode(uid,
3712                            app.info.packageName);
3713                } catch (RemoteException e) {
3714                    throw e.rethrowAsRuntimeException();
3715                }
3716
3717                /*
3718                 * Add shared application and profile GIDs so applications can share some
3719                 * resources like shared libraries and access user-wide resources
3720                 */
3721                if (ArrayUtils.isEmpty(permGids)) {
3722                    gids = new int[2];
3723                } else {
3724                    gids = new int[permGids.length + 2];
3725                    System.arraycopy(permGids, 0, gids, 2, permGids.length);
3726                }
3727                gids[0] = UserHandle.getSharedAppGid(UserHandle.getAppId(uid));
3728                gids[1] = UserHandle.getUserGid(UserHandle.getUserId(uid));
3729            }
3730            checkTime(startTime, "startProcess: building args");
3731            if (mFactoryTest != FactoryTest.FACTORY_TEST_OFF) {
3732                if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL
3733                        && mTopComponent != null
3734                        && app.processName.equals(mTopComponent.getPackageName())) {
3735                    uid = 0;
3736                }
3737                if (mFactoryTest == FactoryTest.FACTORY_TEST_HIGH_LEVEL
3738                        && (app.info.flags&ApplicationInfo.FLAG_FACTORY_TEST) != 0) {
3739                    uid = 0;
3740                }
3741            }
3742            int debugFlags = 0;
3743            if ((app.info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
3744                debugFlags |= Zygote.DEBUG_ENABLE_DEBUGGER;
3745                // Also turn on CheckJNI for debuggable apps. It's quite
3746                // awkward to turn on otherwise.
3747                debugFlags |= Zygote.DEBUG_ENABLE_CHECKJNI;
3748            }
3749            // Run the app in safe mode if its manifest requests so or the
3750            // system is booted in safe mode.
3751            if ((app.info.flags & ApplicationInfo.FLAG_VM_SAFE_MODE) != 0 ||
3752                mSafeMode == true) {
3753                debugFlags |= Zygote.DEBUG_ENABLE_SAFEMODE;
3754            }
3755            if ("1".equals(SystemProperties.get("debug.checkjni"))) {
3756                debugFlags |= Zygote.DEBUG_ENABLE_CHECKJNI;
3757            }
3758            String genDebugInfoProperty = SystemProperties.get("debug.generate-debug-info");
3759            if ("true".equals(genDebugInfoProperty)) {
3760                debugFlags |= Zygote.DEBUG_GENERATE_DEBUG_INFO;
3761            }
3762            if ("1".equals(SystemProperties.get("debug.jni.logging"))) {
3763                debugFlags |= Zygote.DEBUG_ENABLE_JNI_LOGGING;
3764            }
3765            if ("1".equals(SystemProperties.get("debug.assert"))) {
3766                debugFlags |= Zygote.DEBUG_ENABLE_ASSERT;
3767            }
3768            if (mNativeDebuggingApp != null && mNativeDebuggingApp.equals(app.processName)) {
3769                // Enable all debug flags required by the native debugger.
3770                debugFlags |= Zygote.DEBUG_ALWAYS_JIT;          // Don't interpret anything
3771                debugFlags |= Zygote.DEBUG_GENERATE_DEBUG_INFO; // Generate debug info
3772                debugFlags |= Zygote.DEBUG_NATIVE_DEBUGGABLE;   // Disbale optimizations
3773                mNativeDebuggingApp = null;
3774            }
3775
3776            String requiredAbi = (abiOverride != null) ? abiOverride : app.info.primaryCpuAbi;
3777            if (requiredAbi == null) {
3778                requiredAbi = Build.SUPPORTED_ABIS[0];
3779            }
3780
3781            String instructionSet = null;
3782            if (app.info.primaryCpuAbi != null) {
3783                instructionSet = VMRuntime.getInstructionSet(app.info.primaryCpuAbi);
3784            }
3785
3786            app.gids = gids;
3787            app.requiredAbi = requiredAbi;
3788            app.instructionSet = instructionSet;
3789
3790            // Start the process.  It will either succeed and return a result containing
3791            // the PID of the new process, or else throw a RuntimeException.
3792            boolean isActivityProcess = (entryPoint == null);
3793            if (entryPoint == null) entryPoint = "android.app.ActivityThread";
3794            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Start proc: " +
3795                    app.processName);
3796            checkTime(startTime, "startProcess: asking zygote to start proc");
3797            Process.ProcessStartResult startResult = Process.start(entryPoint,
3798                    app.processName, uid, uid, gids, debugFlags, mountExternal,
3799                    app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
3800                    app.info.dataDir, entryPointArgs);
3801            checkTime(startTime, "startProcess: returned from zygote!");
3802            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
3803
3804            mBatteryStatsService.noteProcessStart(app.processName, app.info.uid);
3805            checkTime(startTime, "startProcess: done updating battery stats");
3806
3807            EventLog.writeEvent(EventLogTags.AM_PROC_START,
3808                    UserHandle.getUserId(uid), startResult.pid, uid,
3809                    app.processName, hostingType,
3810                    hostingNameStr != null ? hostingNameStr : "");
3811
3812            try {
3813                AppGlobals.getPackageManager().logAppProcessStartIfNeeded(app.processName, app.uid,
3814                        app.info.seinfo, app.info.sourceDir, startResult.pid);
3815            } catch (RemoteException ex) {
3816                // Ignore
3817            }
3818
3819            if (app.persistent) {
3820                Watchdog.getInstance().processStarted(app.processName, startResult.pid);
3821            }
3822
3823            checkTime(startTime, "startProcess: building log message");
3824            StringBuilder buf = mStringBuilder;
3825            buf.setLength(0);
3826            buf.append("Start proc ");
3827            buf.append(startResult.pid);
3828            buf.append(':');
3829            buf.append(app.processName);
3830            buf.append('/');
3831            UserHandle.formatUid(buf, uid);
3832            if (!isActivityProcess) {
3833                buf.append(" [");
3834                buf.append(entryPoint);
3835                buf.append("]");
3836            }
3837            buf.append(" for ");
3838            buf.append(hostingType);
3839            if (hostingNameStr != null) {
3840                buf.append(" ");
3841                buf.append(hostingNameStr);
3842            }
3843            Slog.i(TAG, buf.toString());
3844            app.setPid(startResult.pid);
3845            app.usingWrapper = startResult.usingWrapper;
3846            app.removed = false;
3847            app.killed = false;
3848            app.killedByAm = false;
3849            checkTime(startTime, "startProcess: starting to update pids map");
3850            ProcessRecord oldApp;
3851            synchronized (mPidsSelfLocked) {
3852                oldApp = mPidsSelfLocked.get(startResult.pid);
3853            }
3854            // If there is already an app occupying that pid that hasn't been cleaned up
3855            if (oldApp != null && !app.isolated) {
3856                // Clean up anything relating to this pid first
3857                Slog.w(TAG, "Reusing pid " + startResult.pid
3858                        + " while app is still mapped to it");
3859                cleanUpApplicationRecordLocked(oldApp, false, false, -1,
3860                        true /*replacingPid*/);
3861            }
3862            synchronized (mPidsSelfLocked) {
3863                this.mPidsSelfLocked.put(startResult.pid, app);
3864                if (isActivityProcess) {
3865                    Message msg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG);
3866                    msg.obj = app;
3867                    mHandler.sendMessageDelayed(msg, startResult.usingWrapper
3868                            ? PROC_START_TIMEOUT_WITH_WRAPPER : PROC_START_TIMEOUT);
3869                }
3870            }
3871            checkTime(startTime, "startProcess: done updating pids map");
3872        } catch (RuntimeException e) {
3873            Slog.e(TAG, "Failure starting process " + app.processName, e);
3874
3875            // Something went very wrong while trying to start this process; one
3876            // common case is when the package is frozen due to an active
3877            // upgrade. To recover, clean up any active bookkeeping related to
3878            // starting this process. (We already invoked this method once when
3879            // the package was initially frozen through KILL_APPLICATION_MSG, so
3880            // it doesn't hurt to use it again.)
3881            forceStopPackageLocked(app.info.packageName, UserHandle.getAppId(app.uid), false,
3882                    false, true, false, false, UserHandle.getUserId(app.userId), "start failure");
3883        }
3884    }
3885
3886    void updateUsageStats(ActivityRecord component, boolean resumed) {
3887        if (DEBUG_SWITCH) Slog.d(TAG_SWITCH,
3888                "updateUsageStats: comp=" + component + "res=" + resumed);
3889        final BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics();
3890        if (resumed) {
3891            if (mUsageStatsService != null) {
3892                mUsageStatsService.reportEvent(component.realActivity, component.userId,
3893                        UsageEvents.Event.MOVE_TO_FOREGROUND);
3894            }
3895            synchronized (stats) {
3896                stats.noteActivityResumedLocked(component.app.uid);
3897            }
3898        } else {
3899            if (mUsageStatsService != null) {
3900                mUsageStatsService.reportEvent(component.realActivity, component.userId,
3901                        UsageEvents.Event.MOVE_TO_BACKGROUND);
3902            }
3903            synchronized (stats) {
3904                stats.noteActivityPausedLocked(component.app.uid);
3905            }
3906        }
3907    }
3908
3909    Intent getHomeIntent() {
3910        Intent intent = new Intent(mTopAction, mTopData != null ? Uri.parse(mTopData) : null);
3911        intent.setComponent(mTopComponent);
3912        intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
3913        if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
3914            intent.addCategory(Intent.CATEGORY_HOME);
3915        }
3916        return intent;
3917    }
3918
3919    boolean startHomeActivityLocked(int userId, String reason) {
3920        if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL
3921                && mTopAction == null) {
3922            // We are running in factory test mode, but unable to find
3923            // the factory test app, so just sit around displaying the
3924            // error message and don't try to start anything.
3925            return false;
3926        }
3927        Intent intent = getHomeIntent();
3928        ActivityInfo aInfo = resolveActivityInfo(intent, STOCK_PM_FLAGS, userId);
3929        if (aInfo != null) {
3930            intent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
3931            // Don't do this if the home app is currently being
3932            // instrumented.
3933            aInfo = new ActivityInfo(aInfo);
3934            aInfo.applicationInfo = getAppInfoForUser(aInfo.applicationInfo, userId);
3935            ProcessRecord app = getProcessRecordLocked(aInfo.processName,
3936                    aInfo.applicationInfo.uid, true);
3937            if (app == null || app.instrumentationClass == null) {
3938                intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK);
3939                mActivityStarter.startHomeActivityLocked(intent, aInfo, reason);
3940            }
3941        } else {
3942            Slog.wtf(TAG, "No home screen found for " + intent, new Throwable());
3943        }
3944
3945        return true;
3946    }
3947
3948    private ActivityInfo resolveActivityInfo(Intent intent, int flags, int userId) {
3949        ActivityInfo ai = null;
3950        ComponentName comp = intent.getComponent();
3951        try {
3952            if (comp != null) {
3953                // Factory test.
3954                ai = AppGlobals.getPackageManager().getActivityInfo(comp, flags, userId);
3955            } else {
3956                ResolveInfo info = AppGlobals.getPackageManager().resolveIntent(
3957                        intent,
3958                        intent.resolveTypeIfNeeded(mContext.getContentResolver()),
3959                        flags, userId);
3960
3961                if (info != null) {
3962                    ai = info.activityInfo;
3963                }
3964            }
3965        } catch (RemoteException e) {
3966            // ignore
3967        }
3968
3969        return ai;
3970    }
3971
3972    /**
3973     * Starts the "new version setup screen" if appropriate.
3974     */
3975    void startSetupActivityLocked() {
3976        // Only do this once per boot.
3977        if (mCheckedForSetup) {
3978            return;
3979        }
3980
3981        // We will show this screen if the current one is a different
3982        // version than the last one shown, and we are not running in
3983        // low-level factory test mode.
3984        final ContentResolver resolver = mContext.getContentResolver();
3985        if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL &&
3986                Settings.Global.getInt(resolver,
3987                        Settings.Global.DEVICE_PROVISIONED, 0) != 0) {
3988            mCheckedForSetup = true;
3989
3990            // See if we should be showing the platform update setup UI.
3991            final Intent intent = new Intent(Intent.ACTION_UPGRADE_SETUP);
3992            final List<ResolveInfo> ris = mContext.getPackageManager().queryIntentActivities(intent,
3993                    PackageManager.MATCH_SYSTEM_ONLY | PackageManager.GET_META_DATA);
3994            if (!ris.isEmpty()) {
3995                final ResolveInfo ri = ris.get(0);
3996                String vers = ri.activityInfo.metaData != null
3997                        ? ri.activityInfo.metaData.getString(Intent.METADATA_SETUP_VERSION)
3998                        : null;
3999                if (vers == null && ri.activityInfo.applicationInfo.metaData != null) {
4000                    vers = ri.activityInfo.applicationInfo.metaData.getString(
4001                            Intent.METADATA_SETUP_VERSION);
4002                }
4003                String lastVers = Settings.Secure.getString(
4004                        resolver, Settings.Secure.LAST_SETUP_SHOWN);
4005                if (vers != null && !vers.equals(lastVers)) {
4006                    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
4007                    intent.setComponent(new ComponentName(
4008                            ri.activityInfo.packageName, ri.activityInfo.name));
4009                    mActivityStarter.startActivityLocked(null, intent, null /*ephemeralIntent*/,
4010                            null, ri.activityInfo, null /*rInfo*/, null, null, null, null, 0, 0, 0,
4011                            null, 0, 0, 0, null, false, false, null, null, null);
4012                }
4013            }
4014        }
4015    }
4016
4017    CompatibilityInfo compatibilityInfoForPackageLocked(ApplicationInfo ai) {
4018        return mCompatModePackages.compatibilityInfoForPackageLocked(ai);
4019    }
4020
4021    void enforceNotIsolatedCaller(String caller) {
4022        if (UserHandle.isIsolated(Binder.getCallingUid())) {
4023            throw new SecurityException("Isolated process not allowed to call " + caller);
4024        }
4025    }
4026
4027    void enforceShellRestriction(String restriction, int userHandle) {
4028        if (Binder.getCallingUid() == Process.SHELL_UID) {
4029            if (userHandle < 0 || mUserController.hasUserRestriction(restriction, userHandle)) {
4030                throw new SecurityException("Shell does not have permission to access user "
4031                        + userHandle);
4032            }
4033        }
4034    }
4035
4036    @Override
4037    public int getFrontActivityScreenCompatMode() {
4038        enforceNotIsolatedCaller("getFrontActivityScreenCompatMode");
4039        synchronized (this) {
4040            return mCompatModePackages.getFrontActivityScreenCompatModeLocked();
4041        }
4042    }
4043
4044    @Override
4045    public void setFrontActivityScreenCompatMode(int mode) {
4046        enforceCallingPermission(android.Manifest.permission.SET_SCREEN_COMPATIBILITY,
4047                "setFrontActivityScreenCompatMode");
4048        synchronized (this) {
4049            mCompatModePackages.setFrontActivityScreenCompatModeLocked(mode);
4050        }
4051    }
4052
4053    @Override
4054    public int getPackageScreenCompatMode(String packageName) {
4055        enforceNotIsolatedCaller("getPackageScreenCompatMode");
4056        synchronized (this) {
4057            return mCompatModePackages.getPackageScreenCompatModeLocked(packageName);
4058        }
4059    }
4060
4061    @Override
4062    public void setPackageScreenCompatMode(String packageName, int mode) {
4063        enforceCallingPermission(android.Manifest.permission.SET_SCREEN_COMPATIBILITY,
4064                "setPackageScreenCompatMode");
4065        synchronized (this) {
4066            mCompatModePackages.setPackageScreenCompatModeLocked(packageName, mode);
4067        }
4068    }
4069
4070    @Override
4071    public boolean getPackageAskScreenCompat(String packageName) {
4072        enforceNotIsolatedCaller("getPackageAskScreenCompat");
4073        synchronized (this) {
4074            return mCompatModePackages.getPackageAskCompatModeLocked(packageName);
4075        }
4076    }
4077
4078    @Override
4079    public void setPackageAskScreenCompat(String packageName, boolean ask) {
4080        enforceCallingPermission(android.Manifest.permission.SET_SCREEN_COMPATIBILITY,
4081                "setPackageAskScreenCompat");
4082        synchronized (this) {
4083            mCompatModePackages.setPackageAskCompatModeLocked(packageName, ask);
4084        }
4085    }
4086
4087    private boolean hasUsageStatsPermission(String callingPackage) {
4088        final int mode = mAppOpsService.checkOperation(AppOpsManager.OP_GET_USAGE_STATS,
4089                Binder.getCallingUid(), callingPackage);
4090        if (mode == AppOpsManager.MODE_DEFAULT) {
4091            return checkCallingPermission(Manifest.permission.PACKAGE_USAGE_STATS)
4092                    == PackageManager.PERMISSION_GRANTED;
4093        }
4094        return mode == AppOpsManager.MODE_ALLOWED;
4095    }
4096
4097    @Override
4098    public int getPackageProcessState(String packageName, String callingPackage) {
4099        if (!hasUsageStatsPermission(callingPackage)) {
4100            enforceCallingPermission(android.Manifest.permission.GET_PACKAGE_IMPORTANCE,
4101                    "getPackageProcessState");
4102        }
4103
4104        int procState = ActivityManager.PROCESS_STATE_NONEXISTENT;
4105        synchronized (this) {
4106            for (int i=mLruProcesses.size()-1; i>=0; i--) {
4107                final ProcessRecord proc = mLruProcesses.get(i);
4108                if (procState == ActivityManager.PROCESS_STATE_NONEXISTENT
4109                        || procState > proc.setProcState) {
4110                    boolean found = false;
4111                    for (int j=proc.pkgList.size()-1; j>=0 && !found; j--) {
4112                        if (proc.pkgList.keyAt(j).equals(packageName)) {
4113                            procState = proc.setProcState;
4114                            found = true;
4115                        }
4116                    }
4117                    if (proc.pkgDeps != null && !found) {
4118                        for (int j=proc.pkgDeps.size()-1; j>=0; j--) {
4119                            if (proc.pkgDeps.valueAt(j).equals(packageName)) {
4120                                procState = proc.setProcState;
4121                                break;
4122                            }
4123                        }
4124                    }
4125                }
4126            }
4127        }
4128        return procState;
4129    }
4130
4131    @Override
4132    public boolean setProcessMemoryTrimLevel(String process, int userId, int level) {
4133        synchronized (this) {
4134            final ProcessRecord app = findProcessLocked(process, userId, "setProcessMemoryTrimLevel");
4135            if (app == null) {
4136                return false;
4137            }
4138            if (app.trimMemoryLevel < level && app.thread != null &&
4139                    (level < ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN ||
4140                            app.curProcState >= ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND)) {
4141                try {
4142                    app.thread.scheduleTrimMemory(level);
4143                    app.trimMemoryLevel = level;
4144                    return true;
4145                } catch (RemoteException e) {
4146                    // Fallthrough to failure case.
4147                }
4148            }
4149        }
4150        return false;
4151    }
4152
4153    private void dispatchProcessesChanged() {
4154        int N;
4155        synchronized (this) {
4156            N = mPendingProcessChanges.size();
4157            if (mActiveProcessChanges.length < N) {
4158                mActiveProcessChanges = new ProcessChangeItem[N];
4159            }
4160            mPendingProcessChanges.toArray(mActiveProcessChanges);
4161            mPendingProcessChanges.clear();
4162            if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG_PROCESS_OBSERVERS,
4163                    "*** Delivering " + N + " process changes");
4164        }
4165
4166        int i = mProcessObservers.beginBroadcast();
4167        while (i > 0) {
4168            i--;
4169            final IProcessObserver observer = mProcessObservers.getBroadcastItem(i);
4170            if (observer != null) {
4171                try {
4172                    for (int j=0; j<N; j++) {
4173                        ProcessChangeItem item = mActiveProcessChanges[j];
4174                        if ((item.changes&ProcessChangeItem.CHANGE_ACTIVITIES) != 0) {
4175                            if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG_PROCESS_OBSERVERS,
4176                                    "ACTIVITIES CHANGED pid=" + item.pid + " uid="
4177                                    + item.uid + ": " + item.foregroundActivities);
4178                            observer.onForegroundActivitiesChanged(item.pid, item.uid,
4179                                    item.foregroundActivities);
4180                        }
4181                        if ((item.changes&ProcessChangeItem.CHANGE_PROCESS_STATE) != 0) {
4182                            if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG_PROCESS_OBSERVERS,
4183                                    "PROCSTATE CHANGED pid=" + item.pid + " uid=" + item.uid
4184                                    + ": " + item.processState);
4185                            observer.onProcessStateChanged(item.pid, item.uid, item.processState);
4186                        }
4187                    }
4188                } catch (RemoteException e) {
4189                }
4190            }
4191        }
4192        mProcessObservers.finishBroadcast();
4193
4194        synchronized (this) {
4195            for (int j=0; j<N; j++) {
4196                mAvailProcessChanges.add(mActiveProcessChanges[j]);
4197            }
4198        }
4199    }
4200
4201    private void dispatchProcessDied(int pid, int uid) {
4202        int i = mProcessObservers.beginBroadcast();
4203        while (i > 0) {
4204            i--;
4205            final IProcessObserver observer = mProcessObservers.getBroadcastItem(i);
4206            if (observer != null) {
4207                try {
4208                    observer.onProcessDied(pid, uid);
4209                } catch (RemoteException e) {
4210                }
4211            }
4212        }
4213        mProcessObservers.finishBroadcast();
4214    }
4215
4216    private void dispatchUidsChanged() {
4217        int N;
4218        synchronized (this) {
4219            N = mPendingUidChanges.size();
4220            if (mActiveUidChanges.length < N) {
4221                mActiveUidChanges = new UidRecord.ChangeItem[N];
4222            }
4223            for (int i=0; i<N; i++) {
4224                final UidRecord.ChangeItem change = mPendingUidChanges.get(i);
4225                mActiveUidChanges[i] = change;
4226                if (change.uidRecord != null) {
4227                    change.uidRecord.pendingChange = null;
4228                    change.uidRecord = null;
4229                }
4230            }
4231            mPendingUidChanges.clear();
4232            if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS,
4233                    "*** Delivering " + N + " uid changes");
4234        }
4235
4236        if (mLocalPowerManager != null) {
4237            for (int j=0; j<N; j++) {
4238                UidRecord.ChangeItem item = mActiveUidChanges[j];
4239                if (item.change == UidRecord.CHANGE_GONE
4240                        || item.change == UidRecord.CHANGE_GONE_IDLE) {
4241                    mLocalPowerManager.uidGone(item.uid);
4242                } else {
4243                    mLocalPowerManager.updateUidProcState(item.uid, item.processState);
4244                }
4245            }
4246        }
4247
4248        int i = mUidObservers.beginBroadcast();
4249        while (i > 0) {
4250            i--;
4251            final IUidObserver observer = mUidObservers.getBroadcastItem(i);
4252            final int which = (Integer)mUidObservers.getBroadcastCookie(i);
4253            if (observer != null) {
4254                try {
4255                    for (int j=0; j<N; j++) {
4256                        UidRecord.ChangeItem item = mActiveUidChanges[j];
4257                        final int change = item.change;
4258                        UidRecord validateUid = null;
4259                        if (VALIDATE_UID_STATES && i == 0) {
4260                            validateUid = mValidateUids.get(item.uid);
4261                            if (validateUid == null && change != UidRecord.CHANGE_GONE
4262                                    && change != UidRecord.CHANGE_GONE_IDLE) {
4263                                validateUid = new UidRecord(item.uid);
4264                                mValidateUids.put(item.uid, validateUid);
4265                            }
4266                        }
4267                        if (change == UidRecord.CHANGE_IDLE
4268                                || change == UidRecord.CHANGE_GONE_IDLE) {
4269                            if ((which & ActivityManager.UID_OBSERVER_IDLE) != 0) {
4270                                if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS,
4271                                        "UID idle uid=" + item.uid);
4272                                observer.onUidIdle(item.uid);
4273                            }
4274                            if (VALIDATE_UID_STATES && i == 0) {
4275                                if (validateUid != null) {
4276                                    validateUid.idle = true;
4277                                }
4278                            }
4279                        } else if (change == UidRecord.CHANGE_ACTIVE) {
4280                            if ((which & ActivityManager.UID_OBSERVER_ACTIVE) != 0) {
4281                                if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS,
4282                                        "UID active uid=" + item.uid);
4283                                observer.onUidActive(item.uid);
4284                            }
4285                            if (VALIDATE_UID_STATES && i == 0) {
4286                                validateUid.idle = false;
4287                            }
4288                        }
4289                        if (change == UidRecord.CHANGE_GONE
4290                                || change == UidRecord.CHANGE_GONE_IDLE) {
4291                            if ((which & ActivityManager.UID_OBSERVER_GONE) != 0) {
4292                                if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS,
4293                                        "UID gone uid=" + item.uid);
4294                                observer.onUidGone(item.uid);
4295                            }
4296                            if (VALIDATE_UID_STATES && i == 0) {
4297                                if (validateUid != null) {
4298                                    mValidateUids.remove(item.uid);
4299                                }
4300                            }
4301                        } else {
4302                            if ((which & ActivityManager.UID_OBSERVER_PROCSTATE) != 0) {
4303                                if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS,
4304                                        "UID CHANGED uid=" + item.uid
4305                                                + ": " + item.processState);
4306                                observer.onUidStateChanged(item.uid, item.processState);
4307                            }
4308                            if (VALIDATE_UID_STATES && i == 0) {
4309                                validateUid.curProcState = validateUid.setProcState
4310                                        = item.processState;
4311                            }
4312                        }
4313                    }
4314                } catch (RemoteException e) {
4315                }
4316            }
4317        }
4318        mUidObservers.finishBroadcast();
4319
4320        synchronized (this) {
4321            for (int j=0; j<N; j++) {
4322                mAvailUidChanges.add(mActiveUidChanges[j]);
4323            }
4324        }
4325    }
4326
4327    @Override
4328    public final int startActivity(IApplicationThread caller, String callingPackage,
4329            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
4330            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
4331        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
4332                resultWho, requestCode, startFlags, profilerInfo, bOptions,
4333                UserHandle.getCallingUserId());
4334    }
4335
4336    final int startActivity(Intent intent, ActivityStackSupervisor.ActivityContainer container) {
4337        enforceNotIsolatedCaller("ActivityContainer.startActivity");
4338        final int userId = mUserController.handleIncomingUser(Binder.getCallingPid(),
4339                Binder.getCallingUid(), mStackSupervisor.mCurrentUser, false,
4340                ActivityManagerService.ALLOW_FULL_ONLY, "ActivityContainer", null);
4341
4342        // TODO: Switch to user app stacks here.
4343        String mimeType = intent.getType();
4344        final Uri data = intent.getData();
4345        if (mimeType == null && data != null && "content".equals(data.getScheme())) {
4346            mimeType = getProviderMimeType(data, userId);
4347        }
4348        container.checkEmbeddedAllowedInner(userId, intent, mimeType);
4349
4350        intent.addFlags(FORCE_NEW_TASK_FLAGS);
4351        return mActivityStarter.startActivityMayWait(null, -1, null, intent, mimeType, null, null, null,
4352                null, 0, 0, null, null, null, null, false, userId, container, null);
4353    }
4354
4355    @Override
4356    public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
4357            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
4358            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
4359        enforceNotIsolatedCaller("startActivity");
4360        userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
4361                userId, false, ALLOW_FULL_ONLY, "startActivity", null);
4362        // TODO: Switch to user app stacks here.
4363        return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
4364                resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
4365                profilerInfo, null, null, bOptions, false, userId, null, null);
4366    }
4367
4368    @Override
4369    public final int startActivityAsCaller(IApplicationThread caller, String callingPackage,
4370            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
4371            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, boolean ignoreTargetSecurity,
4372            int userId) {
4373
4374        // This is very dangerous -- it allows you to perform a start activity (including
4375        // permission grants) as any app that may launch one of your own activities.  So
4376        // we will only allow this to be done from activities that are part of the core framework,
4377        // and then only when they are running as the system.
4378        final ActivityRecord sourceRecord;
4379        final int targetUid;
4380        final String targetPackage;
4381        synchronized (this) {
4382            if (resultTo == null) {
4383                throw new SecurityException("Must be called from an activity");
4384            }
4385            sourceRecord = mStackSupervisor.isInAnyStackLocked(resultTo);
4386            if (sourceRecord == null) {
4387                throw new SecurityException("Called with bad activity token: " + resultTo);
4388            }
4389            if (!sourceRecord.info.packageName.equals("android")) {
4390                throw new SecurityException(
4391                        "Must be called from an activity that is declared in the android package");
4392            }
4393            if (sourceRecord.app == null) {
4394                throw new SecurityException("Called without a process attached to activity");
4395            }
4396            if (UserHandle.getAppId(sourceRecord.app.uid) != Process.SYSTEM_UID) {
4397                // This is still okay, as long as this activity is running under the
4398                // uid of the original calling activity.
4399                if (sourceRecord.app.uid != sourceRecord.launchedFromUid) {
4400                    throw new SecurityException(
4401                            "Calling activity in uid " + sourceRecord.app.uid
4402                                    + " must be system uid or original calling uid "
4403                                    + sourceRecord.launchedFromUid);
4404                }
4405            }
4406            if (ignoreTargetSecurity) {
4407                if (intent.getComponent() == null) {
4408                    throw new SecurityException(
4409                            "Component must be specified with ignoreTargetSecurity");
4410                }
4411                if (intent.getSelector() != null) {
4412                    throw new SecurityException(
4413                            "Selector not allowed with ignoreTargetSecurity");
4414                }
4415            }
4416            targetUid = sourceRecord.launchedFromUid;
4417            targetPackage = sourceRecord.launchedFromPackage;
4418        }
4419
4420        if (userId == UserHandle.USER_NULL) {
4421            userId = UserHandle.getUserId(sourceRecord.app.uid);
4422        }
4423
4424        // TODO: Switch to user app stacks here.
4425        try {
4426            int ret = mActivityStarter.startActivityMayWait(null, targetUid, targetPackage, intent,
4427                    resolvedType, null, null, resultTo, resultWho, requestCode, startFlags, null,
4428                    null, null, bOptions, ignoreTargetSecurity, userId, null, null);
4429            return ret;
4430        } catch (SecurityException e) {
4431            // XXX need to figure out how to propagate to original app.
4432            // A SecurityException here is generally actually a fault of the original
4433            // calling activity (such as a fairly granting permissions), so propagate it
4434            // back to them.
4435            /*
4436            StringBuilder msg = new StringBuilder();
4437            msg.append("While launching");
4438            msg.append(intent.toString());
4439            msg.append(": ");
4440            msg.append(e.getMessage());
4441            */
4442            throw e;
4443        }
4444    }
4445
4446    @Override
4447    public final WaitResult startActivityAndWait(IApplicationThread caller, String callingPackage,
4448            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
4449            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
4450        enforceNotIsolatedCaller("startActivityAndWait");
4451        userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
4452                userId, false, ALLOW_FULL_ONLY, "startActivityAndWait", null);
4453        WaitResult res = new WaitResult();
4454        // TODO: Switch to user app stacks here.
4455        mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent, resolvedType,
4456                null, null, resultTo, resultWho, requestCode, startFlags, profilerInfo, res, null,
4457                bOptions, false, userId, null, null);
4458        return res;
4459    }
4460
4461    @Override
4462    public final int startActivityWithConfig(IApplicationThread caller, String callingPackage,
4463            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
4464            int startFlags, Configuration config, Bundle bOptions, int userId) {
4465        enforceNotIsolatedCaller("startActivityWithConfig");
4466        userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
4467                userId, false, ALLOW_FULL_ONLY, "startActivityWithConfig", null);
4468        // TODO: Switch to user app stacks here.
4469        int ret = mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
4470                resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
4471                null, null, config, bOptions, false, userId, null, null);
4472        return ret;
4473    }
4474
4475    @Override
4476    public int startActivityIntentSender(IApplicationThread caller, IntentSender intent,
4477            Intent fillInIntent, String resolvedType, IBinder resultTo, String resultWho,
4478            int requestCode, int flagsMask, int flagsValues, Bundle bOptions)
4479            throws TransactionTooLargeException {
4480        enforceNotIsolatedCaller("startActivityIntentSender");
4481        // Refuse possible leaked file descriptors
4482        if (fillInIntent != null && fillInIntent.hasFileDescriptors()) {
4483            throw new IllegalArgumentException("File descriptors passed in Intent");
4484        }
4485
4486        IIntentSender sender = intent.getTarget();
4487        if (!(sender instanceof PendingIntentRecord)) {
4488            throw new IllegalArgumentException("Bad PendingIntent object");
4489        }
4490
4491        PendingIntentRecord pir = (PendingIntentRecord)sender;
4492
4493        synchronized (this) {
4494            // If this is coming from the currently resumed activity, it is
4495            // effectively saying that app switches are allowed at this point.
4496            final ActivityStack stack = getFocusedStack();
4497            if (stack.mResumedActivity != null &&
4498                    stack.mResumedActivity.info.applicationInfo.uid == Binder.getCallingUid()) {
4499                mAppSwitchesAllowedTime = 0;
4500            }
4501        }
4502        int ret = pir.sendInner(0, fillInIntent, resolvedType, null, null,
4503                resultTo, resultWho, requestCode, flagsMask, flagsValues, bOptions, null);
4504        return ret;
4505    }
4506
4507    @Override
4508    public int startVoiceActivity(String callingPackage, int callingPid, int callingUid,
4509            Intent intent, String resolvedType, IVoiceInteractionSession session,
4510            IVoiceInteractor interactor, int startFlags, ProfilerInfo profilerInfo,
4511            Bundle bOptions, int userId) {
4512        if (checkCallingPermission(Manifest.permission.BIND_VOICE_INTERACTION)
4513                != PackageManager.PERMISSION_GRANTED) {
4514            String msg = "Permission Denial: startVoiceActivity() from pid="
4515                    + Binder.getCallingPid()
4516                    + ", uid=" + Binder.getCallingUid()
4517                    + " requires " + android.Manifest.permission.BIND_VOICE_INTERACTION;
4518            Slog.w(TAG, msg);
4519            throw new SecurityException(msg);
4520        }
4521        if (session == null || interactor == null) {
4522            throw new NullPointerException("null session or interactor");
4523        }
4524        userId = mUserController.handleIncomingUser(callingPid, callingUid, userId, false,
4525                ALLOW_FULL_ONLY, "startVoiceActivity", null);
4526        // TODO: Switch to user app stacks here.
4527        return mActivityStarter.startActivityMayWait(null, callingUid, callingPackage, intent,
4528                resolvedType, session, interactor, null, null, 0, startFlags, profilerInfo, null,
4529                null, bOptions, false, userId, null, null);
4530    }
4531
4532    @Override
4533    public void startLocalVoiceInteraction(IBinder callingActivity, Bundle options)
4534            throws RemoteException {
4535        Slog.i(TAG, "Activity tried to startVoiceInteraction");
4536        synchronized (this) {
4537            ActivityRecord activity = getFocusedStack().topActivity();
4538            if (ActivityRecord.forTokenLocked(callingActivity) != activity) {
4539                throw new SecurityException("Only focused activity can call startVoiceInteraction");
4540            }
4541            if (mRunningVoice != null || activity.task.voiceSession != null
4542                    || activity.voiceSession != null) {
4543                Slog.w(TAG, "Already in a voice interaction, cannot start new voice interaction");
4544                return;
4545            }
4546            if (activity.pendingVoiceInteractionStart) {
4547                Slog.w(TAG, "Pending start of voice interaction already.");
4548                return;
4549            }
4550            activity.pendingVoiceInteractionStart = true;
4551        }
4552        LocalServices.getService(VoiceInteractionManagerInternal.class)
4553                .startLocalVoiceInteraction(callingActivity, options);
4554    }
4555
4556    @Override
4557    public void stopLocalVoiceInteraction(IBinder callingActivity) throws RemoteException {
4558        LocalServices.getService(VoiceInteractionManagerInternal.class)
4559                .stopLocalVoiceInteraction(callingActivity);
4560    }
4561
4562    @Override
4563    public boolean supportsLocalVoiceInteraction() throws RemoteException {
4564        return LocalServices.getService(VoiceInteractionManagerInternal.class)
4565                .supportsLocalVoiceInteraction();
4566    }
4567
4568    void onLocalVoiceInteractionStartedLocked(IBinder activity,
4569            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor) {
4570        ActivityRecord activityToCallback = ActivityRecord.forTokenLocked(activity);
4571        if (activityToCallback == null) return;
4572        activityToCallback.setVoiceSessionLocked(voiceSession);
4573
4574        // Inform the activity
4575        try {
4576            activityToCallback.app.thread.scheduleLocalVoiceInteractionStarted(activity,
4577                    voiceInteractor);
4578            long token = Binder.clearCallingIdentity();
4579            try {
4580                startRunningVoiceLocked(voiceSession, activityToCallback.appInfo.uid);
4581            } finally {
4582                Binder.restoreCallingIdentity(token);
4583            }
4584            // TODO: VI Should we cache the activity so that it's easier to find later
4585            // rather than scan through all the stacks and activities?
4586        } catch (RemoteException re) {
4587            activityToCallback.clearVoiceSessionLocked();
4588            // TODO: VI Should this terminate the voice session?
4589        }
4590    }
4591
4592    @Override
4593    public void setVoiceKeepAwake(IVoiceInteractionSession session, boolean keepAwake) {
4594        synchronized (this) {
4595            if (mRunningVoice != null && mRunningVoice.asBinder() == session.asBinder()) {
4596                if (keepAwake) {
4597                    mVoiceWakeLock.acquire();
4598                } else {
4599                    mVoiceWakeLock.release();
4600                }
4601            }
4602        }
4603    }
4604
4605    @Override
4606    public boolean startNextMatchingActivity(IBinder callingActivity,
4607            Intent intent, Bundle bOptions) {
4608        // Refuse possible leaked file descriptors
4609        if (intent != null && intent.hasFileDescriptors() == true) {
4610            throw new IllegalArgumentException("File descriptors passed in Intent");
4611        }
4612        ActivityOptions options = ActivityOptions.fromBundle(bOptions);
4613
4614        synchronized (this) {
4615            final ActivityRecord r = ActivityRecord.isInStackLocked(callingActivity);
4616            if (r == null) {
4617                ActivityOptions.abort(options);
4618                return false;
4619            }
4620            if (r.app == null || r.app.thread == null) {
4621                // The caller is not running...  d'oh!
4622                ActivityOptions.abort(options);
4623                return false;
4624            }
4625            intent = new Intent(intent);
4626            // The caller is not allowed to change the data.
4627            intent.setDataAndType(r.intent.getData(), r.intent.getType());
4628            // And we are resetting to find the next component...
4629            intent.setComponent(null);
4630
4631            final boolean debug = ((intent.getFlags() & Intent.FLAG_DEBUG_LOG_RESOLUTION) != 0);
4632
4633            ActivityInfo aInfo = null;
4634            try {
4635                List<ResolveInfo> resolves =
4636                    AppGlobals.getPackageManager().queryIntentActivities(
4637                            intent, r.resolvedType,
4638                            PackageManager.MATCH_DEFAULT_ONLY | STOCK_PM_FLAGS,
4639                            UserHandle.getCallingUserId()).getList();
4640
4641                // Look for the original activity in the list...
4642                final int N = resolves != null ? resolves.size() : 0;
4643                for (int i=0; i<N; i++) {
4644                    ResolveInfo rInfo = resolves.get(i);
4645                    if (rInfo.activityInfo.packageName.equals(r.packageName)
4646                            && rInfo.activityInfo.name.equals(r.info.name)) {
4647                        // We found the current one...  the next matching is
4648                        // after it.
4649                        i++;
4650                        if (i<N) {
4651                            aInfo = resolves.get(i).activityInfo;
4652                        }
4653                        if (debug) {
4654                            Slog.v(TAG, "Next matching activity: found current " + r.packageName
4655                                    + "/" + r.info.name);
4656                            Slog.v(TAG, "Next matching activity: next is " + ((aInfo == null)
4657                                    ? "null" : aInfo.packageName + "/" + aInfo.name));
4658                        }
4659                        break;
4660                    }
4661                }
4662            } catch (RemoteException e) {
4663            }
4664
4665            if (aInfo == null) {
4666                // Nobody who is next!
4667                ActivityOptions.abort(options);
4668                if (debug) Slog.d(TAG, "Next matching activity: nothing found");
4669                return false;
4670            }
4671
4672            intent.setComponent(new ComponentName(
4673                    aInfo.applicationInfo.packageName, aInfo.name));
4674            intent.setFlags(intent.getFlags()&~(
4675                    Intent.FLAG_ACTIVITY_FORWARD_RESULT|
4676                    Intent.FLAG_ACTIVITY_CLEAR_TOP|
4677                    Intent.FLAG_ACTIVITY_MULTIPLE_TASK|
4678                    Intent.FLAG_ACTIVITY_NEW_TASK));
4679
4680            // Okay now we need to start the new activity, replacing the
4681            // currently running activity.  This is a little tricky because
4682            // we want to start the new one as if the current one is finished,
4683            // but not finish the current one first so that there is no flicker.
4684            // And thus...
4685            final boolean wasFinishing = r.finishing;
4686            r.finishing = true;
4687
4688            // Propagate reply information over to the new activity.
4689            final ActivityRecord resultTo = r.resultTo;
4690            final String resultWho = r.resultWho;
4691            final int requestCode = r.requestCode;
4692            r.resultTo = null;
4693            if (resultTo != null) {
4694                resultTo.removeResultsLocked(r, resultWho, requestCode);
4695            }
4696
4697            final long origId = Binder.clearCallingIdentity();
4698            int res = mActivityStarter.startActivityLocked(r.app.thread, intent,
4699                    null /*ephemeralIntent*/, r.resolvedType, aInfo, null /*rInfo*/, null,
4700                    null, resultTo != null ? resultTo.appToken : null, resultWho, requestCode, -1,
4701                    r.launchedFromUid, r.launchedFromPackage, -1, r.launchedFromUid, 0, options,
4702                    false, false, null, null, null);
4703            Binder.restoreCallingIdentity(origId);
4704
4705            r.finishing = wasFinishing;
4706            if (res != ActivityManager.START_SUCCESS) {
4707                return false;
4708            }
4709            return true;
4710        }
4711    }
4712
4713    @Override
4714    public final int startActivityFromRecents(int taskId, Bundle bOptions) {
4715        if (checkCallingPermission(START_TASKS_FROM_RECENTS) != PackageManager.PERMISSION_GRANTED) {
4716            String msg = "Permission Denial: startActivityFromRecents called without " +
4717                    START_TASKS_FROM_RECENTS;
4718            Slog.w(TAG, msg);
4719            throw new SecurityException(msg);
4720        }
4721        final long origId = Binder.clearCallingIdentity();
4722        try {
4723            synchronized (this) {
4724                return mStackSupervisor.startActivityFromRecentsInner(taskId, bOptions);
4725            }
4726        } finally {
4727            Binder.restoreCallingIdentity(origId);
4728        }
4729    }
4730
4731    final int startActivityInPackage(int uid, String callingPackage,
4732            Intent intent, String resolvedType, IBinder resultTo,
4733            String resultWho, int requestCode, int startFlags, Bundle bOptions, int userId,
4734            IActivityContainer container, TaskRecord inTask) {
4735
4736        userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
4737                userId, false, ALLOW_FULL_ONLY, "startActivityInPackage", null);
4738
4739        // TODO: Switch to user app stacks here.
4740        int ret = mActivityStarter.startActivityMayWait(null, uid, callingPackage, intent,
4741                resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
4742                null, null, null, bOptions, false, userId, container, inTask);
4743        return ret;
4744    }
4745
4746    @Override
4747    public final int startActivities(IApplicationThread caller, String callingPackage,
4748            Intent[] intents, String[] resolvedTypes, IBinder resultTo, Bundle bOptions,
4749            int userId) {
4750        enforceNotIsolatedCaller("startActivities");
4751        userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
4752                userId, false, ALLOW_FULL_ONLY, "startActivity", null);
4753        // TODO: Switch to user app stacks here.
4754        int ret = mActivityStarter.startActivities(caller, -1, callingPackage, intents,
4755                resolvedTypes, resultTo, bOptions, userId);
4756        return ret;
4757    }
4758
4759    final int startActivitiesInPackage(int uid, String callingPackage,
4760            Intent[] intents, String[] resolvedTypes, IBinder resultTo,
4761            Bundle bOptions, int userId) {
4762
4763        userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
4764                userId, false, ALLOW_FULL_ONLY, "startActivityInPackage", null);
4765        // TODO: Switch to user app stacks here.
4766        int ret = mActivityStarter.startActivities(null, uid, callingPackage, intents, resolvedTypes,
4767                resultTo, bOptions, userId);
4768        return ret;
4769    }
4770
4771    @Override
4772    public void reportActivityFullyDrawn(IBinder token) {
4773        synchronized (this) {
4774            ActivityRecord r =