1 /*
2  * Copyright (C) 2006 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.app;
18 
19 import android.app.assist.AssistContent;
20 import android.app.assist.AssistStructure;
21 import android.app.backup.BackupAgent;
22 import android.content.BroadcastReceiver;
23 import android.content.ComponentCallbacks2;
24 import android.content.ComponentName;
25 import android.content.ContentProvider;
26 import android.content.Context;
27 import android.content.IContentProvider;
28 import android.content.Intent;
29 import android.content.IIntentReceiver;
30 import android.content.pm.ActivityInfo;
31 import android.content.pm.ApplicationInfo;
32 import android.content.pm.IPackageManager;
33 import android.content.pm.InstrumentationInfo;
34 import android.content.pm.PackageInfo;
35 import android.content.pm.PackageManager;
36 import android.content.pm.PackageManager.NameNotFoundException;
37 import android.content.pm.ProviderInfo;
38 import android.content.pm.ServiceInfo;
39 import android.content.res.AssetManager;
40 import android.content.res.CompatibilityInfo;
41 import android.content.res.Configuration;
42 import android.content.res.Resources;
43 import android.content.res.Resources.Theme;
44 import android.database.sqlite.SQLiteDatabase;
45 import android.database.sqlite.SQLiteDebug;
46 import android.database.sqlite.SQLiteDebug.DbStats;
47 import android.graphics.Bitmap;
48 import android.graphics.Canvas;
49 import android.hardware.display.DisplayManagerGlobal;
50 import android.net.ConnectivityManager;
51 import android.net.IConnectivityManager;
52 import android.net.Network;
53 import android.net.Proxy;
54 import android.net.ProxyInfo;
55 import android.net.Uri;
56 import android.opengl.GLUtils;
57 import android.os.AsyncTask;
58 import android.os.Binder;
59 import android.os.Bundle;
60 import android.os.Debug;
61 import android.os.DropBoxManager;
62 import android.os.Environment;
63 import android.os.Handler;
64 import android.os.IBinder;
65 import android.os.Looper;
66 import android.os.Message;
67 import android.os.MessageQueue;
68 import android.os.Parcel;
69 import android.os.ParcelFileDescriptor;
70 import android.os.PersistableBundle;
71 import android.os.Process;
72 import android.os.RemoteException;
73 import android.os.ServiceManager;
74 import android.os.StrictMode;
75 import android.os.SystemClock;
76 import android.os.SystemProperties;
77 import android.os.Trace;
78 import android.os.UserHandle;
79 import android.provider.Settings;
80 import android.security.NetworkSecurityPolicy;
81 import android.util.AndroidRuntimeException;
82 import android.util.ArrayMap;
83 import android.util.DisplayMetrics;
84 import android.util.EventLog;
85 import android.util.Log;
86 import android.util.LogPrinter;
87 import android.util.Pair;
88 import android.util.PrintWriterPrinter;
89 import android.util.Slog;
90 import android.util.SuperNotCalledException;
91 import android.view.Display;
92 import android.view.HardwareRenderer;
93 import android.view.View;
94 import android.view.ViewDebug;
95 import android.view.ViewManager;
96 import android.view.ViewRootImpl;
97 import android.view.Window;
98 import android.view.WindowManager;
99 import android.view.WindowManagerGlobal;
100 import android.renderscript.RenderScriptCacheDir;
101 import android.security.keystore.AndroidKeyStoreProvider;
102 
103 import com.android.internal.app.IVoiceInteractor;
104 import com.android.internal.content.ReferrerIntent;
105 import com.android.internal.os.BinderInternal;
106 import com.android.internal.os.RuntimeInit;
107 import com.android.internal.os.SamplingProfilerIntegration;
108 import com.android.internal.util.FastPrintWriter;
109 import com.android.org.conscrypt.OpenSSLSocketImpl;
110 import com.android.org.conscrypt.TrustedCertificateStore;
111 import com.google.android.collect.Lists;
112 
113 import java.io.File;
114 import java.io.FileDescriptor;
115 import java.io.FileOutputStream;
116 import java.io.IOException;
117 import java.io.PrintWriter;
118 import java.lang.ref.WeakReference;
119 import java.net.InetAddress;
120 import java.text.DateFormat;
121 import java.util.ArrayList;
122 import java.util.List;
123 import java.util.Locale;
124 import java.util.Map;
125 import java.util.Objects;
126 import java.util.TimeZone;
127 
128 import libcore.io.DropBox;
129 import libcore.io.EventLogger;
130 import libcore.io.IoUtils;
131 import libcore.net.event.NetworkEventDispatcher;
132 import dalvik.system.CloseGuard;
133 import dalvik.system.VMDebug;
134 import dalvik.system.VMRuntime;
135 
136 final class RemoteServiceException extends AndroidRuntimeException {
RemoteServiceException(String msg)137     public RemoteServiceException(String msg) {
138         super(msg);
139     }
140 }
141 
142 /**
143  * This manages the execution of the main thread in an
144  * application process, scheduling and executing activities,
145  * broadcasts, and other operations on it as the activity
146  * manager requests.
147  *
148  * {@hide}
149  */
150 public final class ActivityThread {
151     /** @hide */
152     public static final String TAG = "ActivityThread";
153     private static final android.graphics.Bitmap.Config THUMBNAIL_FORMAT = Bitmap.Config.RGB_565;
154     static final boolean localLOGV = false;
155     static final boolean DEBUG_MESSAGES = false;
156     /** @hide */
157     public static final boolean DEBUG_BROADCAST = false;
158     private static final boolean DEBUG_RESULTS = false;
159     private static final boolean DEBUG_BACKUP = false;
160     public static final boolean DEBUG_CONFIGURATION = false;
161     private static final boolean DEBUG_SERVICE = false;
162     private static final boolean DEBUG_MEMORY_TRIM = false;
163     private static final boolean DEBUG_PROVIDER = false;
164     private static final long MIN_TIME_BETWEEN_GCS = 5*1000;
165     private static final int SQLITE_MEM_RELEASED_EVENT_LOG_TAG = 75003;
166     private static final int LOG_AM_ON_PAUSE_CALLED = 30021;
167     private static final int LOG_AM_ON_RESUME_CALLED = 30022;
168 
169     /** Type for IActivityManager.serviceDoneExecuting: anonymous operation */
170     public static final int SERVICE_DONE_EXECUTING_ANON = 0;
171     /** Type for IActivityManager.serviceDoneExecuting: done with an onStart call */
172     public static final int SERVICE_DONE_EXECUTING_START = 1;
173     /** Type for IActivityManager.serviceDoneExecuting: done stopping (destroying) service */
174     public static final int SERVICE_DONE_EXECUTING_STOP = 2;
175 
176     private ContextImpl mSystemContext;
177 
178     static IPackageManager sPackageManager;
179 
180     final ApplicationThread mAppThread = new ApplicationThread();
181     final Looper mLooper = Looper.myLooper();
182     final H mH = new H();
183     final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>();
184     // List of new activities (via ActivityRecord.nextIdle) that should
185     // be reported when next we idle.
186     ActivityClientRecord mNewActivities = null;
187     // Number of activities that are currently visible on-screen.
188     int mNumVisibleActivities = 0;
189     WeakReference<AssistStructure> mLastAssistStructure;
190     final ArrayMap<IBinder, Service> mServices = new ArrayMap<>();
191     AppBindData mBoundApplication;
192     Profiler mProfiler;
193     int mCurDefaultDisplayDpi;
194     boolean mDensityCompatMode;
195     Configuration mConfiguration;
196     Configuration mCompatConfiguration;
197     Application mInitialApplication;
198     final ArrayList<Application> mAllApplications
199             = new ArrayList<Application>();
200     // set of instantiated backup agents, keyed by package name
201     final ArrayMap<String, BackupAgent> mBackupAgents = new ArrayMap<String, BackupAgent>();
202     /** Reference to singleton {@link ActivityThread} */
203     private static ActivityThread sCurrentActivityThread;
204     Instrumentation mInstrumentation;
205     String mInstrumentationPackageName = null;
206     String mInstrumentationAppDir = null;
207     String[] mInstrumentationSplitAppDirs = null;
208     String mInstrumentationLibDir = null;
209     String mInstrumentedAppDir = null;
210     String[] mInstrumentedSplitAppDirs = null;
211     String mInstrumentedLibDir = null;
212     boolean mSystemThread = false;
213     boolean mJitEnabled = false;
214     boolean mSomeActivitiesChanged = false;
215 
216     // These can be accessed by multiple threads; mPackages is the lock.
217     // XXX For now we keep around information about all packages we have
218     // seen, not removing entries from this map.
219     // NOTE: The activity and window managers need to call in to
220     // ActivityThread to do things like update resource configurations,
221     // which means this lock gets held while the activity and window managers
222     // holds their own lock.  Thus you MUST NEVER call back into the activity manager
223     // or window manager or anything that depends on them while holding this lock.
224     // These LoadedApk are only valid for the userId that we're running as.
225     final ArrayMap<String, WeakReference<LoadedApk>> mPackages
226             = new ArrayMap<String, WeakReference<LoadedApk>>();
227     final ArrayMap<String, WeakReference<LoadedApk>> mResourcePackages
228             = new ArrayMap<String, WeakReference<LoadedApk>>();
229     final ArrayList<ActivityClientRecord> mRelaunchingActivities
230             = new ArrayList<ActivityClientRecord>();
231     Configuration mPendingConfiguration = null;
232 
233     private final ResourcesManager mResourcesManager;
234 
235     private static final class ProviderKey {
236         final String authority;
237         final int userId;
238 
ProviderKey(String authority, int userId)239         public ProviderKey(String authority, int userId) {
240             this.authority = authority;
241             this.userId = userId;
242         }
243 
244         @Override
equals(Object o)245         public boolean equals(Object o) {
246             if (o instanceof ProviderKey) {
247                 final ProviderKey other = (ProviderKey) o;
248                 return Objects.equals(authority, other.authority) && userId == other.userId;
249             }
250             return false;
251         }
252 
253         @Override
hashCode()254         public int hashCode() {
255             return ((authority != null) ? authority.hashCode() : 0) ^ userId;
256         }
257     }
258 
259     // The lock of mProviderMap protects the following variables.
260     final ArrayMap<ProviderKey, ProviderClientRecord> mProviderMap
261         = new ArrayMap<ProviderKey, ProviderClientRecord>();
262     final ArrayMap<IBinder, ProviderRefCount> mProviderRefCountMap
263         = new ArrayMap<IBinder, ProviderRefCount>();
264     final ArrayMap<IBinder, ProviderClientRecord> mLocalProviders
265         = new ArrayMap<IBinder, ProviderClientRecord>();
266     final ArrayMap<ComponentName, ProviderClientRecord> mLocalProvidersByName
267             = new ArrayMap<ComponentName, ProviderClientRecord>();
268 
269     final ArrayMap<Activity, ArrayList<OnActivityPausedListener>> mOnPauseListeners
270         = new ArrayMap<Activity, ArrayList<OnActivityPausedListener>>();
271 
272     final GcIdler mGcIdler = new GcIdler();
273     boolean mGcIdlerScheduled = false;
274 
275     static Handler sMainThreadHandler;  // set once in main()
276 
277     Bundle mCoreSettings = null;
278 
279     static final class ActivityClientRecord {
280         IBinder token;
281         int ident;
282         Intent intent;
283         String referrer;
284         IVoiceInteractor voiceInteractor;
285         Bundle state;
286         PersistableBundle persistentState;
287         Activity activity;
288         Window window;
289         Activity parent;
290         String embeddedID;
291         Activity.NonConfigurationInstances lastNonConfigurationInstances;
292         boolean paused;
293         boolean stopped;
294         boolean hideForNow;
295         Configuration newConfig;
296         Configuration createdConfig;
297         Configuration overrideConfig;
298         // Used for consolidating configs before sending on to Activity.
299         private Configuration tmpConfig = new Configuration();
300         ActivityClientRecord nextIdle;
301 
302         ProfilerInfo profilerInfo;
303 
304         ActivityInfo activityInfo;
305         CompatibilityInfo compatInfo;
306         LoadedApk packageInfo;
307 
308         List<ResultInfo> pendingResults;
309         List<ReferrerIntent> pendingIntents;
310 
311         boolean startsNotResumed;
312         boolean isForward;
313         int pendingConfigChanges;
314         boolean onlyLocalRequest;
315 
316         View mPendingRemoveWindow;
317         WindowManager mPendingRemoveWindowManager;
318 
ActivityClientRecord()319         ActivityClientRecord() {
320             parent = null;
321             embeddedID = null;
322             paused = false;
323             stopped = false;
324             hideForNow = false;
325             nextIdle = null;
326         }
327 
isPreHoneycomb()328         public boolean isPreHoneycomb() {
329             if (activity != null) {
330                 return activity.getApplicationInfo().targetSdkVersion
331                         < android.os.Build.VERSION_CODES.HONEYCOMB;
332             }
333             return false;
334         }
335 
isPersistable()336         public boolean isPersistable() {
337             return activityInfo.persistableMode == ActivityInfo.PERSIST_ACROSS_REBOOTS;
338         }
339 
toString()340         public String toString() {
341             ComponentName componentName = intent != null ? intent.getComponent() : null;
342             return "ActivityRecord{"
343                 + Integer.toHexString(System.identityHashCode(this))
344                 + " token=" + token + " " + (componentName == null
345                         ? "no component name" : componentName.toShortString())
346                 + "}";
347         }
348     }
349 
350     final class ProviderClientRecord {
351         final String[] mNames;
352         final IContentProvider mProvider;
353         final ContentProvider mLocalProvider;
354         final IActivityManager.ContentProviderHolder mHolder;
355 
ProviderClientRecord(String[] names, IContentProvider provider, ContentProvider localProvider, IActivityManager.ContentProviderHolder holder)356         ProviderClientRecord(String[] names, IContentProvider provider,
357                 ContentProvider localProvider,
358                 IActivityManager.ContentProviderHolder holder) {
359             mNames = names;
360             mProvider = provider;
361             mLocalProvider = localProvider;
362             mHolder = holder;
363         }
364     }
365 
366     static final class NewIntentData {
367         List<ReferrerIntent> intents;
368         IBinder token;
toString()369         public String toString() {
370             return "NewIntentData{intents=" + intents + " token=" + token + "}";
371         }
372     }
373 
374     static final class ReceiverData extends BroadcastReceiver.PendingResult {
ReceiverData(Intent intent, int resultCode, String resultData, Bundle resultExtras, boolean ordered, boolean sticky, IBinder token, int sendingUser)375         public ReceiverData(Intent intent, int resultCode, String resultData, Bundle resultExtras,
376                 boolean ordered, boolean sticky, IBinder token, int sendingUser) {
377             super(resultCode, resultData, resultExtras, TYPE_COMPONENT, ordered, sticky,
378                     token, sendingUser, intent.getFlags());
379             this.intent = intent;
380         }
381 
382         Intent intent;
383         ActivityInfo info;
384         CompatibilityInfo compatInfo;
toString()385         public String toString() {
386             return "ReceiverData{intent=" + intent + " packageName=" +
387                     info.packageName + " resultCode=" + getResultCode()
388                     + " resultData=" + getResultData() + " resultExtras="
389                     + getResultExtras(false) + "}";
390         }
391     }
392 
393     static final class CreateBackupAgentData {
394         ApplicationInfo appInfo;
395         CompatibilityInfo compatInfo;
396         int backupMode;
toString()397         public String toString() {
398             return "CreateBackupAgentData{appInfo=" + appInfo
399                     + " backupAgent=" + appInfo.backupAgentName
400                     + " mode=" + backupMode + "}";
401         }
402     }
403 
404     static final class CreateServiceData {
405         IBinder token;
406         ServiceInfo info;
407         CompatibilityInfo compatInfo;
408         Intent intent;
toString()409         public String toString() {
410             return "CreateServiceData{token=" + token + " className="
411             + info.name + " packageName=" + info.packageName
412             + " intent=" + intent + "}";
413         }
414     }
415 
416     static final class BindServiceData {
417         IBinder token;
418         Intent intent;
419         boolean rebind;
toString()420         public String toString() {
421             return "BindServiceData{token=" + token + " intent=" + intent + "}";
422         }
423     }
424 
425     static final class ServiceArgsData {
426         IBinder token;
427         boolean taskRemoved;
428         int startId;
429         int flags;
430         Intent args;
toString()431         public String toString() {
432             return "ServiceArgsData{token=" + token + " startId=" + startId
433             + " args=" + args + "}";
434         }
435     }
436 
437     static final class AppBindData {
438         LoadedApk info;
439         String processName;
440         ApplicationInfo appInfo;
441         List<ProviderInfo> providers;
442         ComponentName instrumentationName;
443         Bundle instrumentationArgs;
444         IInstrumentationWatcher instrumentationWatcher;
445         IUiAutomationConnection instrumentationUiAutomationConnection;
446         int debugMode;
447         boolean enableOpenGlTrace;
448         boolean restrictedBackupMode;
449         boolean persistent;
450         Configuration config;
451         CompatibilityInfo compatInfo;
452 
453         /** Initial values for {@link Profiler}. */
454         ProfilerInfo initProfilerInfo;
455 
toString()456         public String toString() {
457             return "AppBindData{appInfo=" + appInfo + "}";
458         }
459     }
460 
461     static final class Profiler {
462         String profileFile;
463         ParcelFileDescriptor profileFd;
464         int samplingInterval;
465         boolean autoStopProfiler;
466         boolean profiling;
467         boolean handlingProfiling;
setProfiler(ProfilerInfo profilerInfo)468         public void setProfiler(ProfilerInfo profilerInfo) {
469             ParcelFileDescriptor fd = profilerInfo.profileFd;
470             if (profiling) {
471                 if (fd != null) {
472                     try {
473                         fd.close();
474                     } catch (IOException e) {
475                         // Ignore
476                     }
477                 }
478                 return;
479             }
480             if (profileFd != null) {
481                 try {
482                     profileFd.close();
483                 } catch (IOException e) {
484                     // Ignore
485                 }
486             }
487             profileFile = profilerInfo.profileFile;
488             profileFd = fd;
489             samplingInterval = profilerInfo.samplingInterval;
490             autoStopProfiler = profilerInfo.autoStopProfiler;
491         }
startProfiling()492         public void startProfiling() {
493             if (profileFd == null || profiling) {
494                 return;
495             }
496             try {
497                 VMDebug.startMethodTracing(profileFile, profileFd.getFileDescriptor(),
498                         8 * 1024 * 1024, 0, samplingInterval != 0, samplingInterval);
499                 profiling = true;
500             } catch (RuntimeException e) {
501                 Slog.w(TAG, "Profiling failed on path " + profileFile);
502                 try {
503                     profileFd.close();
504                     profileFd = null;
505                 } catch (IOException e2) {
506                     Slog.w(TAG, "Failure closing profile fd", e2);
507                 }
508             }
509         }
stopProfiling()510         public void stopProfiling() {
511             if (profiling) {
512                 profiling = false;
513                 Debug.stopMethodTracing();
514                 if (profileFd != null) {
515                     try {
516                         profileFd.close();
517                     } catch (IOException e) {
518                     }
519                 }
520                 profileFd = null;
521                 profileFile = null;
522             }
523         }
524     }
525 
526     static final class DumpComponentInfo {
527         ParcelFileDescriptor fd;
528         IBinder token;
529         String prefix;
530         String[] args;
531     }
532 
533     static final class ResultData {
534         IBinder token;
535         List<ResultInfo> results;
toString()536         public String toString() {
537             return "ResultData{token=" + token + " results" + results + "}";
538         }
539     }
540 
541     static final class ContextCleanupInfo {
542         ContextImpl context;
543         String what;
544         String who;
545     }
546 
547     static final class DumpHeapData {
548         String path;
549         ParcelFileDescriptor fd;
550     }
551 
552     static final class UpdateCompatibilityData {
553         String pkg;
554         CompatibilityInfo info;
555     }
556 
557     static final class RequestAssistContextExtras {
558         IBinder activityToken;
559         IBinder requestToken;
560         int requestType;
561     }
562 
563     static final class ActivityConfigChangeData {
564         final IBinder activityToken;
565         final Configuration overrideConfig;
ActivityConfigChangeData(IBinder token, Configuration config)566         public ActivityConfigChangeData(IBinder token, Configuration config) {
567             activityToken = token;
568             overrideConfig = config;
569         }
570     }
571 
dumpGraphicsInfo(FileDescriptor fd)572     private native void dumpGraphicsInfo(FileDescriptor fd);
573 
574     private class ApplicationThread extends ApplicationThreadNative {
575         private static final String DB_INFO_FORMAT = "  %8s %8s %14s %14s  %s";
576 
577         private int mLastProcessState = -1;
578 
updatePendingConfiguration(Configuration config)579         private void updatePendingConfiguration(Configuration config) {
580             synchronized (mResourcesManager) {
581                 if (mPendingConfiguration == null ||
582                         mPendingConfiguration.isOtherSeqNewer(config)) {
583                     mPendingConfiguration = config;
584                 }
585             }
586         }
587 
schedulePauseActivity(IBinder token, boolean finished, boolean userLeaving, int configChanges, boolean dontReport)588         public final void schedulePauseActivity(IBinder token, boolean finished,
589                 boolean userLeaving, int configChanges, boolean dontReport) {
590             sendMessage(
591                     finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
592                     token,
593                     (userLeaving ? 1 : 0) | (dontReport ? 2 : 0),
594                     configChanges);
595         }
596 
scheduleStopActivity(IBinder token, boolean showWindow, int configChanges)597         public final void scheduleStopActivity(IBinder token, boolean showWindow,
598                 int configChanges) {
599            sendMessage(
600                 showWindow ? H.STOP_ACTIVITY_SHOW : H.STOP_ACTIVITY_HIDE,
601                 token, 0, configChanges);
602         }
603 
scheduleWindowVisibility(IBinder token, boolean showWindow)604         public final void scheduleWindowVisibility(IBinder token, boolean showWindow) {
605             sendMessage(
606                 showWindow ? H.SHOW_WINDOW : H.HIDE_WINDOW,
607                 token);
608         }
609 
scheduleSleeping(IBinder token, boolean sleeping)610         public final void scheduleSleeping(IBinder token, boolean sleeping) {
611             sendMessage(H.SLEEPING, token, sleeping ? 1 : 0);
612         }
613 
scheduleResumeActivity(IBinder token, int processState, boolean isForward, Bundle resumeArgs)614         public final void scheduleResumeActivity(IBinder token, int processState,
615                 boolean isForward, Bundle resumeArgs) {
616             updateProcessState(processState, false);
617             sendMessage(H.RESUME_ACTIVITY, token, isForward ? 1 : 0);
618         }
619 
scheduleSendResult(IBinder token, List<ResultInfo> results)620         public final void scheduleSendResult(IBinder token, List<ResultInfo> results) {
621             ResultData res = new ResultData();
622             res.token = token;
623             res.results = results;
624             sendMessage(H.SEND_RESULT, res);
625         }
626 
627         // we use token to identify this activity without having to send the
628         // activity itself back to the activity manager. (matters more with ipc)
629         @Override
scheduleLaunchActivity(Intent intent, IBinder token, int ident, ActivityInfo info, Configuration curConfig, Configuration overrideConfig, CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor, int procState, Bundle state, PersistableBundle persistentState, List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents, boolean notResumed, boolean isForward, ProfilerInfo profilerInfo)630         public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
631                 ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
632                 CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
633                 int procState, Bundle state, PersistableBundle persistentState,
634                 List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
635                 boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
636 
637             updateProcessState(procState, false);
638 
639             ActivityClientRecord r = new ActivityClientRecord();
640 
641             r.token = token;
642             r.ident = ident;
643             r.intent = intent;
644             r.referrer = referrer;
645             r.voiceInteractor = voiceInteractor;
646             r.activityInfo = info;
647             r.compatInfo = compatInfo;
648             r.state = state;
649             r.persistentState = persistentState;
650 
651             r.pendingResults = pendingResults;
652             r.pendingIntents = pendingNewIntents;
653 
654             r.startsNotResumed = notResumed;
655             r.isForward = isForward;
656 
657             r.profilerInfo = profilerInfo;
658 
659             r.overrideConfig = overrideConfig;
660             updatePendingConfiguration(curConfig);
661 
662             sendMessage(H.LAUNCH_ACTIVITY, r);
663         }
664 
665         @Override
scheduleRelaunchActivity(IBinder token, List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents, int configChanges, boolean notResumed, Configuration config, Configuration overrideConfig)666         public final void scheduleRelaunchActivity(IBinder token,
667                 List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
668                 int configChanges, boolean notResumed, Configuration config,
669                 Configuration overrideConfig) {
670             requestRelaunchActivity(token, pendingResults, pendingNewIntents,
671                     configChanges, notResumed, config, overrideConfig, true);
672         }
673 
scheduleNewIntent(List<ReferrerIntent> intents, IBinder token)674         public final void scheduleNewIntent(List<ReferrerIntent> intents, IBinder token) {
675             NewIntentData data = new NewIntentData();
676             data.intents = intents;
677             data.token = token;
678 
679             sendMessage(H.NEW_INTENT, data);
680         }
681 
scheduleDestroyActivity(IBinder token, boolean finishing, int configChanges)682         public final void scheduleDestroyActivity(IBinder token, boolean finishing,
683                 int configChanges) {
684             sendMessage(H.DESTROY_ACTIVITY, token, finishing ? 1 : 0,
685                     configChanges);
686         }
687 
scheduleReceiver(Intent intent, ActivityInfo info, CompatibilityInfo compatInfo, int resultCode, String data, Bundle extras, boolean sync, int sendingUser, int processState)688         public final void scheduleReceiver(Intent intent, ActivityInfo info,
689                 CompatibilityInfo compatInfo, int resultCode, String data, Bundle extras,
690                 boolean sync, int sendingUser, int processState) {
691             updateProcessState(processState, false);
692             ReceiverData r = new ReceiverData(intent, resultCode, data, extras,
693                     sync, false, mAppThread.asBinder(), sendingUser);
694             r.info = info;
695             r.compatInfo = compatInfo;
696             sendMessage(H.RECEIVER, r);
697         }
698 
scheduleCreateBackupAgent(ApplicationInfo app, CompatibilityInfo compatInfo, int backupMode)699         public final void scheduleCreateBackupAgent(ApplicationInfo app,
700                 CompatibilityInfo compatInfo, int backupMode) {
701             CreateBackupAgentData d = new CreateBackupAgentData();
702             d.appInfo = app;
703             d.compatInfo = compatInfo;
704             d.backupMode = backupMode;
705 
706             sendMessage(H.CREATE_BACKUP_AGENT, d);
707         }
708 
scheduleDestroyBackupAgent(ApplicationInfo app, CompatibilityInfo compatInfo)709         public final void scheduleDestroyBackupAgent(ApplicationInfo app,
710                 CompatibilityInfo compatInfo) {
711             CreateBackupAgentData d = new CreateBackupAgentData();
712             d.appInfo = app;
713             d.compatInfo = compatInfo;
714 
715             sendMessage(H.DESTROY_BACKUP_AGENT, d);
716         }
717 
scheduleCreateService(IBinder token, ServiceInfo info, CompatibilityInfo compatInfo, int processState)718         public final void scheduleCreateService(IBinder token,
719                 ServiceInfo info, CompatibilityInfo compatInfo, int processState) {
720             updateProcessState(processState, false);
721             CreateServiceData s = new CreateServiceData();
722             s.token = token;
723             s.info = info;
724             s.compatInfo = compatInfo;
725 
726             sendMessage(H.CREATE_SERVICE, s);
727         }
728 
scheduleBindService(IBinder token, Intent intent, boolean rebind, int processState)729         public final void scheduleBindService(IBinder token, Intent intent,
730                 boolean rebind, int processState) {
731             updateProcessState(processState, false);
732             BindServiceData s = new BindServiceData();
733             s.token = token;
734             s.intent = intent;
735             s.rebind = rebind;
736 
737             if (DEBUG_SERVICE)
738                 Slog.v(TAG, "scheduleBindService token=" + token + " intent=" + intent + " uid="
739                         + Binder.getCallingUid() + " pid=" + Binder.getCallingPid());
740             sendMessage(H.BIND_SERVICE, s);
741         }
742 
scheduleUnbindService(IBinder token, Intent intent)743         public final void scheduleUnbindService(IBinder token, Intent intent) {
744             BindServiceData s = new BindServiceData();
745             s.token = token;
746             s.intent = intent;
747 
748             sendMessage(H.UNBIND_SERVICE, s);
749         }
750 
scheduleServiceArgs(IBinder token, boolean taskRemoved, int startId, int flags ,Intent args)751         public final void scheduleServiceArgs(IBinder token, boolean taskRemoved, int startId,
752             int flags ,Intent args) {
753             ServiceArgsData s = new ServiceArgsData();
754             s.token = token;
755             s.taskRemoved = taskRemoved;
756             s.startId = startId;
757             s.flags = flags;
758             s.args = args;
759 
760             sendMessage(H.SERVICE_ARGS, s);
761         }
762 
scheduleStopService(IBinder token)763         public final void scheduleStopService(IBinder token) {
764             sendMessage(H.STOP_SERVICE, token);
765         }
766 
bindApplication(String processName, ApplicationInfo appInfo, List<ProviderInfo> providers, ComponentName instrumentationName, ProfilerInfo profilerInfo, Bundle instrumentationArgs, IInstrumentationWatcher instrumentationWatcher, IUiAutomationConnection instrumentationUiConnection, int debugMode, boolean enableOpenGlTrace, boolean isRestrictedBackupMode, boolean persistent, Configuration config, CompatibilityInfo compatInfo, Map<String, IBinder> services, Bundle coreSettings)767         public final void bindApplication(String processName, ApplicationInfo appInfo,
768                 List<ProviderInfo> providers, ComponentName instrumentationName,
769                 ProfilerInfo profilerInfo, Bundle instrumentationArgs,
770                 IInstrumentationWatcher instrumentationWatcher,
771                 IUiAutomationConnection instrumentationUiConnection, int debugMode,
772                 boolean enableOpenGlTrace, boolean isRestrictedBackupMode, boolean persistent,
773                 Configuration config, CompatibilityInfo compatInfo, Map<String, IBinder> services,
774                 Bundle coreSettings) {
775 
776             if (services != null) {
777                 // Setup the service cache in the ServiceManager
778                 ServiceManager.initServiceCache(services);
779             }
780 
781             setCoreSettings(coreSettings);
782 
783             /*
784              * Two possible indications that this package could be
785              * sharing its runtime with other packages:
786              *
787              * 1.) the sharedUserId attribute is set in the manifest,
788              *     indicating a request to share a VM with other
789              *     packages with the same sharedUserId.
790              *
791              * 2.) the application element of the manifest has an
792              *     attribute specifying a non-default process name,
793              *     indicating the desire to run in another packages VM.
794              *
795              * If sharing is enabled we do not have a unique application
796              * in a process and therefore cannot rely on the package
797              * name inside the runtime.
798              */
799             IPackageManager pm = getPackageManager();
800             android.content.pm.PackageInfo pi = null;
801             try {
802                 pi = pm.getPackageInfo(appInfo.packageName, 0, UserHandle.myUserId());
803             } catch (RemoteException e) {
804             }
805             if (pi != null) {
806                 boolean sharedUserIdSet = (pi.sharedUserId != null);
807                 boolean processNameNotDefault =
808                 (pi.applicationInfo != null &&
809                  !appInfo.packageName.equals(pi.applicationInfo.processName));
810                 boolean sharable = (sharedUserIdSet || processNameNotDefault);
811 
812                 // Tell the VMRuntime about the application, unless it is shared
813                 // inside a process.
814                 if (!sharable) {
815                     VMRuntime.registerAppInfo(appInfo.packageName, appInfo.dataDir,
816                                             appInfo.processName);
817                 }
818             }
819 
820             AppBindData data = new AppBindData();
821             data.processName = processName;
822             data.appInfo = appInfo;
823             data.providers = providers;
824             data.instrumentationName = instrumentationName;
825             data.instrumentationArgs = instrumentationArgs;
826             data.instrumentationWatcher = instrumentationWatcher;
827             data.instrumentationUiAutomationConnection = instrumentationUiConnection;
828             data.debugMode = debugMode;
829             data.enableOpenGlTrace = enableOpenGlTrace;
830             data.restrictedBackupMode = isRestrictedBackupMode;
831             data.persistent = persistent;
832             data.config = config;
833             data.compatInfo = compatInfo;
834             data.initProfilerInfo = profilerInfo;
835             sendMessage(H.BIND_APPLICATION, data);
836         }
837 
scheduleExit()838         public final void scheduleExit() {
839             sendMessage(H.EXIT_APPLICATION, null);
840         }
841 
scheduleSuicide()842         public final void scheduleSuicide() {
843             sendMessage(H.SUICIDE, null);
844         }
845 
scheduleConfigurationChanged(Configuration config)846         public void scheduleConfigurationChanged(Configuration config) {
847             updatePendingConfiguration(config);
848             sendMessage(H.CONFIGURATION_CHANGED, config);
849         }
850 
updateTimeZone()851         public void updateTimeZone() {
852             TimeZone.setDefault(null);
853         }
854 
clearDnsCache()855         public void clearDnsCache() {
856             // a non-standard API to get this to libcore
857             InetAddress.clearDnsCache();
858             // Allow libcore to perform the necessary actions as it sees fit upon a network
859             // configuration change.
860             NetworkEventDispatcher.getInstance().onNetworkConfigurationChanged();
861         }
862 
setHttpProxy(String host, String port, String exclList, Uri pacFileUrl)863         public void setHttpProxy(String host, String port, String exclList, Uri pacFileUrl) {
864             final ConnectivityManager cm = ConnectivityManager.from(getSystemContext());
865             final Network network = cm.getBoundNetworkForProcess();
866             if (network != null) {
867                 Proxy.setHttpProxySystemProperty(cm.getDefaultProxy());
868             } else {
869                 Proxy.setHttpProxySystemProperty(host, port, exclList, pacFileUrl);
870             }
871         }
872 
processInBackground()873         public void processInBackground() {
874             mH.removeMessages(H.GC_WHEN_IDLE);
875             mH.sendMessage(mH.obtainMessage(H.GC_WHEN_IDLE));
876         }
877 
dumpService(FileDescriptor fd, IBinder servicetoken, String[] args)878         public void dumpService(FileDescriptor fd, IBinder servicetoken, String[] args) {
879             DumpComponentInfo data = new DumpComponentInfo();
880             try {
881                 data.fd = ParcelFileDescriptor.dup(fd);
882                 data.token = servicetoken;
883                 data.args = args;
884                 sendMessage(H.DUMP_SERVICE, data, 0, 0, true /*async*/);
885             } catch (IOException e) {
886                 Slog.w(TAG, "dumpService failed", e);
887             }
888         }
889 
890         // This function exists to make sure all receiver dispatching is
891         // correctly ordered, since these are one-way calls and the binder driver
892         // applies transaction ordering per object for such calls.
scheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent, int resultCode, String dataStr, Bundle extras, boolean ordered, boolean sticky, int sendingUser, int processState)893         public void scheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent,
894                 int resultCode, String dataStr, Bundle extras, boolean ordered,
895                 boolean sticky, int sendingUser, int processState) throws RemoteException {
896             updateProcessState(processState, false);
897             receiver.performReceive(intent, resultCode, dataStr, extras, ordered,
898                     sticky, sendingUser);
899         }
900 
901         @Override
scheduleLowMemory()902         public void scheduleLowMemory() {
903             sendMessage(H.LOW_MEMORY, null);
904         }
905 
906         @Override
scheduleActivityConfigurationChanged( IBinder token, Configuration overrideConfig)907         public void scheduleActivityConfigurationChanged(
908                 IBinder token, Configuration overrideConfig) {
909             sendMessage(H.ACTIVITY_CONFIGURATION_CHANGED,
910                     new ActivityConfigChangeData(token, overrideConfig));
911         }
912 
913         @Override
profilerControl(boolean start, ProfilerInfo profilerInfo, int profileType)914         public void profilerControl(boolean start, ProfilerInfo profilerInfo, int profileType) {
915             sendMessage(H.PROFILER_CONTROL, profilerInfo, start ? 1 : 0, profileType);
916         }
917 
dumpHeap(boolean managed, String path, ParcelFileDescriptor fd)918         public void dumpHeap(boolean managed, String path, ParcelFileDescriptor fd) {
919             DumpHeapData dhd = new DumpHeapData();
920             dhd.path = path;
921             dhd.fd = fd;
922             sendMessage(H.DUMP_HEAP, dhd, managed ? 1 : 0, 0, true /*async*/);
923         }
924 
setSchedulingGroup(int group)925         public void setSchedulingGroup(int group) {
926             // Note: do this immediately, since going into the foreground
927             // should happen regardless of what pending work we have to do
928             // and the activity manager will wait for us to report back that
929             // we are done before sending us to the background.
930             try {
931                 Process.setProcessGroup(Process.myPid(), group);
932             } catch (Exception e) {
933                 Slog.w(TAG, "Failed setting process group to " + group, e);
934             }
935         }
936 
dispatchPackageBroadcast(int cmd, String[] packages)937         public void dispatchPackageBroadcast(int cmd, String[] packages) {
938             sendMessage(H.DISPATCH_PACKAGE_BROADCAST, packages, cmd);
939         }
940 
scheduleCrash(String msg)941         public void scheduleCrash(String msg) {
942             sendMessage(H.SCHEDULE_CRASH, msg);
943         }
944 
dumpActivity(FileDescriptor fd, IBinder activitytoken, String prefix, String[] args)945         public void dumpActivity(FileDescriptor fd, IBinder activitytoken,
946                 String prefix, String[] args) {
947             DumpComponentInfo data = new DumpComponentInfo();
948             try {
949                 data.fd = ParcelFileDescriptor.dup(fd);
950                 data.token = activitytoken;
951                 data.prefix = prefix;
952                 data.args = args;
953                 sendMessage(H.DUMP_ACTIVITY, data, 0, 0, true /*async*/);
954             } catch (IOException e) {
955                 Slog.w(TAG, "dumpActivity failed", e);
956             }
957         }
958 
dumpProvider(FileDescriptor fd, IBinder providertoken, String[] args)959         public void dumpProvider(FileDescriptor fd, IBinder providertoken,
960                 String[] args) {
961             DumpComponentInfo data = new DumpComponentInfo();
962             try {
963                 data.fd = ParcelFileDescriptor.dup(fd);
964                 data.token = providertoken;
965                 data.args = args;
966                 sendMessage(H.DUMP_PROVIDER, data, 0, 0, true /*async*/);
967             } catch (IOException e) {
968                 Slog.w(TAG, "dumpProvider failed", e);
969             }
970         }
971 
972         @Override
dumpMemInfo(FileDescriptor fd, Debug.MemoryInfo mem, boolean checkin, boolean dumpFullInfo, boolean dumpDalvik, boolean dumpSummaryOnly, String[] args)973         public void dumpMemInfo(FileDescriptor fd, Debug.MemoryInfo mem, boolean checkin,
974                 boolean dumpFullInfo, boolean dumpDalvik, boolean dumpSummaryOnly, String[] args) {
975             FileOutputStream fout = new FileOutputStream(fd);
976             PrintWriter pw = new FastPrintWriter(fout);
977             try {
978                 dumpMemInfo(pw, mem, checkin, dumpFullInfo, dumpDalvik, dumpSummaryOnly);
979             } finally {
980                 pw.flush();
981             }
982         }
983 
dumpMemInfo(PrintWriter pw, Debug.MemoryInfo memInfo, boolean checkin, boolean dumpFullInfo, boolean dumpDalvik, boolean dumpSummaryOnly)984         private void dumpMemInfo(PrintWriter pw, Debug.MemoryInfo memInfo, boolean checkin,
985                 boolean dumpFullInfo, boolean dumpDalvik, boolean dumpSummaryOnly) {
986             long nativeMax = Debug.getNativeHeapSize() / 1024;
987             long nativeAllocated = Debug.getNativeHeapAllocatedSize() / 1024;
988             long nativeFree = Debug.getNativeHeapFreeSize() / 1024;
989 
990             Runtime runtime = Runtime.getRuntime();
991 
992             long dalvikMax = runtime.totalMemory() / 1024;
993             long dalvikFree = runtime.freeMemory() / 1024;
994             long dalvikAllocated = dalvikMax - dalvikFree;
995             long viewInstanceCount = ViewDebug.getViewInstanceCount();
996             long viewRootInstanceCount = ViewDebug.getViewRootImplCount();
997             long appContextInstanceCount = Debug.countInstancesOfClass(ContextImpl.class);
998             long activityInstanceCount = Debug.countInstancesOfClass(Activity.class);
999             int globalAssetCount = AssetManager.getGlobalAssetCount();
1000             int globalAssetManagerCount = AssetManager.getGlobalAssetManagerCount();
1001             int binderLocalObjectCount = Debug.getBinderLocalObjectCount();
1002             int binderProxyObjectCount = Debug.getBinderProxyObjectCount();
1003             int binderDeathObjectCount = Debug.getBinderDeathObjectCount();
1004             long parcelSize = Parcel.getGlobalAllocSize();
1005             long parcelCount = Parcel.getGlobalAllocCount();
1006             long openSslSocketCount = Debug.countInstancesOfClass(OpenSSLSocketImpl.class);
1007             SQLiteDebug.PagerStats stats = SQLiteDebug.getDatabaseInfo();
1008 
1009             dumpMemInfoTable(pw, memInfo, checkin, dumpFullInfo, dumpDalvik, dumpSummaryOnly,
1010                     Process.myPid(),
1011                     (mBoundApplication != null) ? mBoundApplication.processName : "unknown",
1012                     nativeMax, nativeAllocated, nativeFree,
1013                     dalvikMax, dalvikAllocated, dalvikFree);
1014 
1015             if (checkin) {
1016                 // NOTE: if you change anything significant below, also consider changing
1017                 // ACTIVITY_THREAD_CHECKIN_VERSION.
1018 
1019                 // Object counts
1020                 pw.print(viewInstanceCount); pw.print(',');
1021                 pw.print(viewRootInstanceCount); pw.print(',');
1022                 pw.print(appContextInstanceCount); pw.print(',');
1023                 pw.print(activityInstanceCount); pw.print(',');
1024 
1025                 pw.print(globalAssetCount); pw.print(',');
1026                 pw.print(globalAssetManagerCount); pw.print(',');
1027                 pw.print(binderLocalObjectCount); pw.print(',');
1028                 pw.print(binderProxyObjectCount); pw.print(',');
1029 
1030                 pw.print(binderDeathObjectCount); pw.print(',');
1031                 pw.print(openSslSocketCount); pw.print(',');
1032 
1033                 // SQL
1034                 pw.print(stats.memoryUsed / 1024); pw.print(',');
1035                 pw.print(stats.memoryUsed / 1024); pw.print(',');
1036                 pw.print(stats.pageCacheOverflow / 1024); pw.print(',');
1037                 pw.print(stats.largestMemAlloc / 1024);
1038                 for (int i = 0; i < stats.dbStats.size(); i++) {
1039                     DbStats dbStats = stats.dbStats.get(i);
1040                     pw.print(','); pw.print(dbStats.dbName);
1041                     pw.print(','); pw.print(dbStats.pageSize);
1042                     pw.print(','); pw.print(dbStats.dbSize);
1043                     pw.print(','); pw.print(dbStats.lookaside);
1044                     pw.print(','); pw.print(dbStats.cache);
1045                     pw.print(','); pw.print(dbStats.cache);
1046                 }
1047                 pw.println();
1048 
1049                 return;
1050             }
1051 
1052             pw.println(" ");
1053             pw.println(" Objects");
1054             printRow(pw, TWO_COUNT_COLUMNS, "Views:", viewInstanceCount, "ViewRootImpl:",
1055                     viewRootInstanceCount);
1056 
1057             printRow(pw, TWO_COUNT_COLUMNS, "AppContexts:", appContextInstanceCount,
1058                     "Activities:", activityInstanceCount);
1059 
1060             printRow(pw, TWO_COUNT_COLUMNS, "Assets:", globalAssetCount,
1061                     "AssetManagers:", globalAssetManagerCount);
1062 
1063             printRow(pw, TWO_COUNT_COLUMNS, "Local Binders:", binderLocalObjectCount,
1064                     "Proxy Binders:", binderProxyObjectCount);
1065             printRow(pw, TWO_COUNT_COLUMNS, "Parcel memory:", parcelSize/1024,
1066                     "Parcel count:", parcelCount);
1067             printRow(pw, TWO_COUNT_COLUMNS, "Death Recipients:", binderDeathObjectCount,
1068                     "OpenSSL Sockets:", openSslSocketCount);
1069 
1070             // SQLite mem info
1071             pw.println(" ");
1072             pw.println(" SQL");
1073             printRow(pw, ONE_COUNT_COLUMN, "MEMORY_USED:", stats.memoryUsed / 1024);
1074             printRow(pw, TWO_COUNT_COLUMNS, "PAGECACHE_OVERFLOW:",
1075                     stats.pageCacheOverflow / 1024, "MALLOC_SIZE:", stats.largestMemAlloc / 1024);
1076             pw.println(" ");
1077             int N = stats.dbStats.size();
1078             if (N > 0) {
1079                 pw.println(" DATABASES");
1080                 printRow(pw, "  %8s %8s %14s %14s  %s", "pgsz", "dbsz", "Lookaside(b)", "cache",
1081                         "Dbname");
1082                 for (int i = 0; i < N; i++) {
1083                     DbStats dbStats = stats.dbStats.get(i);
1084                     printRow(pw, DB_INFO_FORMAT,
1085                             (dbStats.pageSize > 0) ? String.valueOf(dbStats.pageSize) : " ",
1086                             (dbStats.dbSize > 0) ? String.valueOf(dbStats.dbSize) : " ",
1087                             (dbStats.lookaside > 0) ? String.valueOf(dbStats.lookaside) : " ",
1088                             dbStats.cache, dbStats.dbName);
1089                 }
1090             }
1091 
1092             // Asset details.
1093             String assetAlloc = AssetManager.getAssetAllocations();
1094             if (assetAlloc != null) {
1095                 pw.println(" ");
1096                 pw.println(" Asset Allocations");
1097                 pw.print(assetAlloc);
1098             }
1099         }
1100 
1101         @Override
dumpGfxInfo(FileDescriptor fd, String[] args)1102         public void dumpGfxInfo(FileDescriptor fd, String[] args) {
1103             dumpGraphicsInfo(fd);
1104             WindowManagerGlobal.getInstance().dumpGfxInfo(fd, args);
1105         }
1106 
dumpDatabaseInfo(FileDescriptor fd, String[] args)1107         private void dumpDatabaseInfo(FileDescriptor fd, String[] args) {
1108             PrintWriter pw = new FastPrintWriter(new FileOutputStream(fd));
1109             PrintWriterPrinter printer = new PrintWriterPrinter(pw);
1110             SQLiteDebug.dump(printer, args);
1111             pw.flush();
1112         }
1113 
1114         @Override
dumpDbInfo(final FileDescriptor fd, final String[] args)1115         public void dumpDbInfo(final FileDescriptor fd, final String[] args) {
1116             if (mSystemThread) {
1117                 // Ensure this invocation is asynchronous to prevent
1118                 // writer waiting due to buffer cannot be consumed.
1119                 AsyncTask.THREAD_POOL_EXECUTOR.execute(new Runnable() {
1120                     @Override
1121                     public void run() {
1122                         dumpDatabaseInfo(fd, args);
1123                     }
1124                 });
1125             } else {
1126                 dumpDatabaseInfo(fd, args);
1127             }
1128         }
1129 
1130         @Override
unstableProviderDied(IBinder provider)1131         public void unstableProviderDied(IBinder provider) {
1132             sendMessage(H.UNSTABLE_PROVIDER_DIED, provider);
1133         }
1134 
1135         @Override
requestAssistContextExtras(IBinder activityToken, IBinder requestToken, int requestType)1136         public void requestAssistContextExtras(IBinder activityToken, IBinder requestToken,
1137                 int requestType) {
1138             RequestAssistContextExtras cmd = new RequestAssistContextExtras();
1139             cmd.activityToken = activityToken;
1140             cmd.requestToken = requestToken;
1141             cmd.requestType = requestType;
1142             sendMessage(H.REQUEST_ASSIST_CONTEXT_EXTRAS, cmd);
1143         }
1144 
setCoreSettings(Bundle coreSettings)1145         public void setCoreSettings(Bundle coreSettings) {
1146             sendMessage(H.SET_CORE_SETTINGS, coreSettings);
1147         }
1148 
updatePackageCompatibilityInfo(String pkg, CompatibilityInfo info)1149         public void updatePackageCompatibilityInfo(String pkg, CompatibilityInfo info) {
1150             UpdateCompatibilityData ucd = new UpdateCompatibilityData();
1151             ucd.pkg = pkg;
1152             ucd.info = info;
1153             sendMessage(H.UPDATE_PACKAGE_COMPATIBILITY_INFO, ucd);
1154         }
1155 
scheduleTrimMemory(int level)1156         public void scheduleTrimMemory(int level) {
1157             sendMessage(H.TRIM_MEMORY, null, level);
1158         }
1159 
scheduleTranslucentConversionComplete(IBinder token, boolean drawComplete)1160         public void scheduleTranslucentConversionComplete(IBinder token, boolean drawComplete) {
1161             sendMessage(H.TRANSLUCENT_CONVERSION_COMPLETE, token, drawComplete ? 1 : 0);
1162         }
1163 
scheduleOnNewActivityOptions(IBinder token, ActivityOptions options)1164         public void scheduleOnNewActivityOptions(IBinder token, ActivityOptions options) {
1165             sendMessage(H.ON_NEW_ACTIVITY_OPTIONS,
1166                     new Pair<IBinder, ActivityOptions>(token, options));
1167         }
1168 
setProcessState(int state)1169         public void setProcessState(int state) {
1170             updateProcessState(state, true);
1171         }
1172 
updateProcessState(int processState, boolean fromIpc)1173         public void updateProcessState(int processState, boolean fromIpc) {
1174             synchronized (this) {
1175                 if (mLastProcessState != processState) {
1176                     mLastProcessState = processState;
1177                     // Update Dalvik state based on ActivityManager.PROCESS_STATE_* constants.
1178                     final int DALVIK_PROCESS_STATE_JANK_PERCEPTIBLE = 0;
1179                     final int DALVIK_PROCESS_STATE_JANK_IMPERCEPTIBLE = 1;
1180                     int dalvikProcessState = DALVIK_PROCESS_STATE_JANK_IMPERCEPTIBLE;
1181                     // TODO: Tune this since things like gmail sync are important background but not jank perceptible.
1182                     if (processState <= ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND) {
1183                         dalvikProcessState = DALVIK_PROCESS_STATE_JANK_PERCEPTIBLE;
1184                     }
1185                     VMRuntime.getRuntime().updateProcessState(dalvikProcessState);
1186                     if (false) {
1187                         Slog.i(TAG, "******************* PROCESS STATE CHANGED TO: " + processState
1188                                 + (fromIpc ? " (from ipc": ""));
1189                     }
1190                 }
1191             }
1192         }
1193 
1194         @Override
scheduleInstallProvider(ProviderInfo provider)1195         public void scheduleInstallProvider(ProviderInfo provider) {
1196             sendMessage(H.INSTALL_PROVIDER, provider);
1197         }
1198 
1199         @Override
updateTimePrefs(boolean is24Hour)1200         public final void updateTimePrefs(boolean is24Hour) {
1201             DateFormat.set24HourTimePref(is24Hour);
1202         }
1203 
1204         @Override
scheduleCancelVisibleBehind(IBinder token)1205         public void scheduleCancelVisibleBehind(IBinder token) {
1206             sendMessage(H.CANCEL_VISIBLE_BEHIND, token);
1207         }
1208 
1209         @Override
scheduleBackgroundVisibleBehindChanged(IBinder token, boolean visible)1210         public void scheduleBackgroundVisibleBehindChanged(IBinder token, boolean visible) {
1211             sendMessage(H.BACKGROUND_VISIBLE_BEHIND_CHANGED, token, visible ? 1 : 0);
1212         }
1213 
1214         @Override
scheduleEnterAnimationComplete(IBinder token)1215         public void scheduleEnterAnimationComplete(IBinder token) {
1216             sendMessage(H.ENTER_ANIMATION_COMPLETE, token);
1217         }
1218 
1219         @Override
notifyCleartextNetwork(byte[] firstPacket)1220         public void notifyCleartextNetwork(byte[] firstPacket) {
1221             if (StrictMode.vmCleartextNetworkEnabled()) {
1222                 StrictMode.onCleartextNetworkDetected(firstPacket);
1223             }
1224         }
1225     }
1226 
1227     private class H extends Handler {
1228         public static final int LAUNCH_ACTIVITY         = 100;
1229         public static final int PAUSE_ACTIVITY          = 101;
1230         public static final int PAUSE_ACTIVITY_FINISHING= 102;
1231         public static final int STOP_ACTIVITY_SHOW      = 103;
1232         public static final int STOP_ACTIVITY_HIDE      = 104;
1233         public static final int SHOW_WINDOW             = 105;
1234         public static final int HIDE_WINDOW             = 106;
1235         public static final int RESUME_ACTIVITY         = 107;
1236         public static final int SEND_RESULT             = 108;
1237         public static final int DESTROY_ACTIVITY        = 109;
1238         public static final int BIND_APPLICATION        = 110;
1239         public static final int EXIT_APPLICATION        = 111;
1240         public static final int NEW_INTENT              = 112;
1241         public static final int RECEIVER                = 113;
1242         public static final int CREATE_SERVICE          = 114;
1243         public static final int SERVICE_ARGS            = 115;
1244         public static final int STOP_SERVICE            = 116;
1245 
1246         public static final int CONFIGURATION_CHANGED   = 118;
1247         public static final int CLEAN_UP_CONTEXT        = 119;
1248         public static final int GC_WHEN_IDLE            = 120;
1249         public static final int BIND_SERVICE            = 121;
1250         public static final int UNBIND_SERVICE          = 122;
1251         public static final int DUMP_SERVICE            = 123;
1252         public static final int LOW_MEMORY              = 124;
1253         public static final int ACTIVITY_CONFIGURATION_CHANGED = 125;
1254         public static final int RELAUNCH_ACTIVITY       = 126;
1255         public static final int PROFILER_CONTROL        = 127;
1256         public static final int CREATE_BACKUP_AGENT     = 128;
1257         public static final int DESTROY_BACKUP_AGENT    = 129;
1258         public static final int SUICIDE                 = 130;
1259         public static final int REMOVE_PROVIDER         = 131;
1260         public static final int ENABLE_JIT              = 132;
1261         public static final int DISPATCH_PACKAGE_BROADCAST = 133;
1262         public static final int SCHEDULE_CRASH          = 134;
1263         public static final int DUMP_HEAP               = 135;
1264         public static final int DUMP_ACTIVITY           = 136;
1265         public static final int SLEEPING                = 137;
1266         public static final int SET_CORE_SETTINGS       = 138;
1267         public static final int UPDATE_PACKAGE_COMPATIBILITY_INFO = 139;
1268         public static final int TRIM_MEMORY             = 140;
1269         public static final int DUMP_PROVIDER           = 141;
1270         public static final int UNSTABLE_PROVIDER_DIED  = 142;
1271         public static final int REQUEST_ASSIST_CONTEXT_EXTRAS = 143;
1272         public static final int TRANSLUCENT_CONVERSION_COMPLETE = 144;
1273         public static final int INSTALL_PROVIDER        = 145;
1274         public static final int ON_NEW_ACTIVITY_OPTIONS = 146;
1275         public static final int CANCEL_VISIBLE_BEHIND = 147;
1276         public static final int BACKGROUND_VISIBLE_BEHIND_CHANGED = 148;
1277         public static final int ENTER_ANIMATION_COMPLETE = 149;
1278 
codeToString(int code)1279         String codeToString(int code) {
1280             if (DEBUG_MESSAGES) {
1281                 switch (code) {
1282                     case LAUNCH_ACTIVITY: return "LAUNCH_ACTIVITY";
1283                     case PAUSE_ACTIVITY: return "PAUSE_ACTIVITY";
1284                     case PAUSE_ACTIVITY_FINISHING: return "PAUSE_ACTIVITY_FINISHING";
1285                     case STOP_ACTIVITY_SHOW: return "STOP_ACTIVITY_SHOW";
1286                     case STOP_ACTIVITY_HIDE: return "STOP_ACTIVITY_HIDE";
1287                     case SHOW_WINDOW: return "SHOW_WINDOW";
1288                     case HIDE_WINDOW: return "HIDE_WINDOW";
1289                     case RESUME_ACTIVITY: return "RESUME_ACTIVITY";
1290                     case SEND_RESULT: return "SEND_RESULT";
1291                     case DESTROY_ACTIVITY: return "DESTROY_ACTIVITY";
1292                     case BIND_APPLICATION: return "BIND_APPLICATION";
1293                     case EXIT_APPLICATION: return "EXIT_APPLICATION";
1294                     case NEW_INTENT: return "NEW_INTENT";
1295                     case RECEIVER: return "RECEIVER";
1296                     case CREATE_SERVICE: return "CREATE_SERVICE";
1297                     case SERVICE_ARGS: return "SERVICE_ARGS";
1298                     case STOP_SERVICE: return "STOP_SERVICE";
1299                     case CONFIGURATION_CHANGED: return "CONFIGURATION_CHANGED";
1300                     case CLEAN_UP_CONTEXT: return "CLEAN_UP_CONTEXT";
1301                     case GC_WHEN_IDLE: return "GC_WHEN_IDLE";
1302                     case BIND_SERVICE: return "BIND_SERVICE";
1303                     case UNBIND_SERVICE: return "UNBIND_SERVICE";
1304                     case DUMP_SERVICE: return "DUMP_SERVICE";
1305                     case LOW_MEMORY: return "LOW_MEMORY";
1306                     case ACTIVITY_CONFIGURATION_CHANGED: return "ACTIVITY_CONFIGURATION_CHANGED";
1307                     case RELAUNCH_ACTIVITY: return "RELAUNCH_ACTIVITY";
1308                     case PROFILER_CONTROL: return "PROFILER_CONTROL";
1309                     case CREATE_BACKUP_AGENT: return "CREATE_BACKUP_AGENT";
1310                     case DESTROY_BACKUP_AGENT: return "DESTROY_BACKUP_AGENT";
1311                     case SUICIDE: return "SUICIDE";
1312                     case REMOVE_PROVIDER: return "REMOVE_PROVIDER";
1313                     case ENABLE_JIT: return "ENABLE_JIT";
1314                     case DISPATCH_PACKAGE_BROADCAST: return "DISPATCH_PACKAGE_BROADCAST";
1315                     case SCHEDULE_CRASH: return "SCHEDULE_CRASH";
1316                     case DUMP_HEAP: return "DUMP_HEAP";
1317                     case DUMP_ACTIVITY: return "DUMP_ACTIVITY";
1318                     case SLEEPING: return "SLEEPING";
1319                     case SET_CORE_SETTINGS: return "SET_CORE_SETTINGS";
1320                     case UPDATE_PACKAGE_COMPATIBILITY_INFO: return "UPDATE_PACKAGE_COMPATIBILITY_INFO";
1321                     case TRIM_MEMORY: return "TRIM_MEMORY";
1322                     case DUMP_PROVIDER: return "DUMP_PROVIDER";
1323                     case UNSTABLE_PROVIDER_DIED: return "UNSTABLE_PROVIDER_DIED";
1324                     case REQUEST_ASSIST_CONTEXT_EXTRAS: return "REQUEST_ASSIST_CONTEXT_EXTRAS";
1325                     case TRANSLUCENT_CONVERSION_COMPLETE: return "TRANSLUCENT_CONVERSION_COMPLETE";
1326                     case INSTALL_PROVIDER: return "INSTALL_PROVIDER";
1327                     case ON_NEW_ACTIVITY_OPTIONS: return "ON_NEW_ACTIVITY_OPTIONS";
1328                     case CANCEL_VISIBLE_BEHIND: return "CANCEL_VISIBLE_BEHIND";
1329                     case BACKGROUND_VISIBLE_BEHIND_CHANGED: return "BACKGROUND_VISIBLE_BEHIND_CHANGED";
1330                     case ENTER_ANIMATION_COMPLETE: return "ENTER_ANIMATION_COMPLETE";
1331                 }
1332             }
1333             return Integer.toString(code);
1334         }
handleMessage(Message msg)1335         public void handleMessage(Message msg) {
1336             if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
1337             switch (msg.what) {
1338                 case LAUNCH_ACTIVITY: {
1339                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
1340                     final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
1341 
1342                     r.packageInfo = getPackageInfoNoCheck(
1343                             r.activityInfo.applicationInfo, r.compatInfo);
1344                     handleLaunchActivity(r, null);
1345                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1346                 } break;
1347                 case RELAUNCH_ACTIVITY: {
1348                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart");
1349                     ActivityClientRecord r = (ActivityClientRecord)msg.obj;
1350                     handleRelaunchActivity(r);
1351                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1352                 } break;
1353                 case PAUSE_ACTIVITY:
1354                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
1355                     handlePauseActivity((IBinder)msg.obj, false, (msg.arg1&1) != 0, msg.arg2,
1356                             (msg.arg1&2) != 0);
1357                     maybeSnapshot();
1358                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1359                     break;
1360                 case PAUSE_ACTIVITY_FINISHING:
1361                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
1362                     handlePauseActivity((IBinder)msg.obj, true, (msg.arg1&1) != 0, msg.arg2,
1363                             (msg.arg1&1) != 0);
1364                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1365                     break;
1366                 case STOP_ACTIVITY_SHOW:
1367                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop");
1368                     handleStopActivity((IBinder)msg.obj, true, msg.arg2);
1369                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1370                     break;
1371                 case STOP_ACTIVITY_HIDE:
1372                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop");
1373                     handleStopActivity((IBinder)msg.obj, false, msg.arg2);
1374                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1375                     break;
1376                 case SHOW_WINDOW:
1377                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityShowWindow");
1378                     handleWindowVisibility((IBinder)msg.obj, true);
1379                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1380                     break;
1381                 case HIDE_WINDOW:
1382                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityHideWindow");
1383                     handleWindowVisibility((IBinder)msg.obj, false);
1384                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1385                     break;
1386                 case RESUME_ACTIVITY:
1387                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
1388                     handleResumeActivity((IBinder) msg.obj, true, msg.arg1 != 0, true);
1389                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1390                     break;
1391                 case SEND_RESULT:
1392                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityDeliverResult");
1393                     handleSendResult((ResultData)msg.obj);
1394                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1395                     break;
1396                 case DESTROY_ACTIVITY:
1397                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityDestroy");
1398                     handleDestroyActivity((IBinder)msg.obj, msg.arg1 != 0,
1399                             msg.arg2, false);
1400                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1401                     break;
1402                 case BIND_APPLICATION:
1403                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
1404                     AppBindData data = (AppBindData)msg.obj;
1405                     handleBindApplication(data);
1406                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1407                     break;
1408                 case EXIT_APPLICATION:
1409                     if (mInitialApplication != null) {
1410                         mInitialApplication.onTerminate();
1411                     }
1412                     Looper.myLooper().quit();
1413                     break;
1414                 case NEW_INTENT:
1415                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityNewIntent");
1416                     handleNewIntent((NewIntentData)msg.obj);
1417                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1418                     break;
1419                 case RECEIVER:
1420                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastReceiveComp");
1421                     handleReceiver((ReceiverData)msg.obj);
1422                     maybeSnapshot();
1423                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1424                     break;
1425                 case CREATE_SERVICE:
1426                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceCreate");
1427                     handleCreateService((CreateServiceData)msg.obj);
1428                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1429                     break;
1430                 case BIND_SERVICE:
1431                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceBind");
1432                     handleBindService((BindServiceData)msg.obj);
1433                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1434                     break;
1435                 case UNBIND_SERVICE:
1436                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceUnbind");
1437                     handleUnbindService((BindServiceData)msg.obj);
1438                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1439                     break;
1440                 case SERVICE_ARGS:
1441                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceStart");
1442                     handleServiceArgs((ServiceArgsData)msg.obj);
1443                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1444                     break;
1445                 case STOP_SERVICE:
1446                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceStop");
1447                     handleStopService((IBinder)msg.obj);
1448                     maybeSnapshot();
1449                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1450                     break;
1451                 case CONFIGURATION_CHANGED:
1452                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "configChanged");
1453                     mCurDefaultDisplayDpi = ((Configuration)msg.obj).densityDpi;
1454                     handleConfigurationChanged((Configuration)msg.obj, null);
1455                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1456                     break;
1457                 case CLEAN_UP_CONTEXT:
1458                     ContextCleanupInfo cci = (ContextCleanupInfo)msg.obj;
1459                     cci.context.performFinalCleanup(cci.who, cci.what);
1460                     break;
1461                 case GC_WHEN_IDLE:
1462                     scheduleGcIdler();
1463                     break;
1464                 case DUMP_SERVICE:
1465                     handleDumpService((DumpComponentInfo)msg.obj);
1466                     break;
1467                 case LOW_MEMORY:
1468                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "lowMemory");
1469                     handleLowMemory();
1470                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1471                     break;
1472                 case ACTIVITY_CONFIGURATION_CHANGED:
1473                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityConfigChanged");
1474                     handleActivityConfigurationChanged((ActivityConfigChangeData)msg.obj);
1475                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1476                     break;
1477                 case PROFILER_CONTROL:
1478                     handleProfilerControl(msg.arg1 != 0, (ProfilerInfo)msg.obj, msg.arg2);
1479                     break;
1480                 case CREATE_BACKUP_AGENT:
1481                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "backupCreateAgent");
1482                     handleCreateBackupAgent((CreateBackupAgentData)msg.obj);
1483                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1484                     break;
1485                 case DESTROY_BACKUP_AGENT:
1486                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "backupDestroyAgent");
1487                     handleDestroyBackupAgent((CreateBackupAgentData)msg.obj);
1488                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1489                     break;
1490                 case SUICIDE:
1491                     Process.killProcess(Process.myPid());
1492                     break;
1493                 case REMOVE_PROVIDER:
1494                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "providerRemove");
1495                     completeRemoveProvider((ProviderRefCount)msg.obj);
1496                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1497                     break;
1498                 case ENABLE_JIT:
1499                     ensureJitEnabled();
1500                     break;
1501                 case DISPATCH_PACKAGE_BROADCAST:
1502                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastPackage");
1503                     handleDispatchPackageBroadcast(msg.arg1, (String[])msg.obj);
1504                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1505                     break;
1506                 case SCHEDULE_CRASH:
1507                     throw new RemoteServiceException((String)msg.obj);
1508                 case DUMP_HEAP:
1509                     handleDumpHeap(msg.arg1 != 0, (DumpHeapData)msg.obj);
1510                     break;
1511                 case DUMP_ACTIVITY:
1512                     handleDumpActivity((DumpComponentInfo)msg.obj);
1513                     break;
1514                 case DUMP_PROVIDER:
1515                     handleDumpProvider((DumpComponentInfo)msg.obj);
1516                     break;
1517                 case SLEEPING:
1518                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "sleeping");
1519                     handleSleeping((IBinder)msg.obj, msg.arg1 != 0);
1520                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1521                     break;
1522                 case SET_CORE_SETTINGS:
1523                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "setCoreSettings");
1524                     handleSetCoreSettings((Bundle) msg.obj);
1525                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1526                     break;
1527                 case UPDATE_PACKAGE_COMPATIBILITY_INFO:
1528                     handleUpdatePackageCompatibilityInfo((UpdateCompatibilityData)msg.obj);
1529                     break;
1530                 case TRIM_MEMORY:
1531                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "trimMemory");
1532                     handleTrimMemory(msg.arg1);
1533                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1534                     break;
1535                 case UNSTABLE_PROVIDER_DIED:
1536                     handleUnstableProviderDied((IBinder)msg.obj, false);
1537                     break;
1538                 case REQUEST_ASSIST_CONTEXT_EXTRAS:
1539                     handleRequestAssistContextExtras((RequestAssistContextExtras)msg.obj);
1540                     break;
1541                 case TRANSLUCENT_CONVERSION_COMPLETE:
1542                     handleTranslucentConversionComplete((IBinder)msg.obj, msg.arg1 == 1);
1543                     break;
1544                 case INSTALL_PROVIDER:
1545                     handleInstallProvider((ProviderInfo) msg.obj);
1546                     break;
1547                 case ON_NEW_ACTIVITY_OPTIONS:
1548                     Pair<IBinder, ActivityOptions> pair = (Pair<IBinder, ActivityOptions>) msg.obj;
1549                     onNewActivityOptions(pair.first, pair.second);
1550                     break;
1551                 case CANCEL_VISIBLE_BEHIND:
1552                     handleCancelVisibleBehind((IBinder) msg.obj);
1553                     break;
1554                 case BACKGROUND_VISIBLE_BEHIND_CHANGED:
1555                     handleOnBackgroundVisibleBehindChanged((IBinder) msg.obj, msg.arg1 > 0);
1556                     break;
1557                 case ENTER_ANIMATION_COMPLETE:
1558                     handleEnterAnimationComplete((IBinder) msg.obj);
1559                     break;
1560             }
1561             if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));
1562         }
1563 
maybeSnapshot()1564         private void maybeSnapshot() {
1565             if (mBoundApplication != null && SamplingProfilerIntegration.isEnabled()) {
1566                 // convert the *private* ActivityThread.PackageInfo to *public* known
1567                 // android.content.pm.PackageInfo
1568                 String packageName = mBoundApplication.info.mPackageName;
1569                 android.content.pm.PackageInfo packageInfo = null;
1570                 try {
1571                     Context context = getSystemContext();
1572                     if(context == null) {
1573                         Log.e(TAG, "cannot get a valid context");
1574                         return;
1575                     }
1576                     PackageManager pm = context.getPackageManager();
1577                     if(pm == null) {
1578                         Log.e(TAG, "cannot get a valid PackageManager");
1579                         return;
1580                     }
1581                     packageInfo = pm.getPackageInfo(
1582                             packageName, PackageManager.GET_ACTIVITIES);
1583                 } catch (NameNotFoundException e) {
1584                     Log.e(TAG, "cannot get package info for " + packageName, e);
1585                 }
1586                 SamplingProfilerIntegration.writeSnapshot(mBoundApplication.processName, packageInfo);
1587             }
1588         }
1589     }
1590 
1591     private class Idler implements MessageQueue.IdleHandler {
1592         @Override
queueIdle()1593         public final boolean queueIdle() {
1594             ActivityClientRecord a = mNewActivities;
1595             boolean stopProfiling = false;
1596             if (mBoundApplication != null && mProfiler.profileFd != null
1597                     && mProfiler.autoStopProfiler) {
1598                 stopProfiling = true;
1599             }
1600             if (a != null) {
1601                 mNewActivities = null;
1602                 IActivityManager am = ActivityManagerNative.getDefault();
1603                 ActivityClientRecord prev;
1604                 do {
1605                     if (localLOGV) Slog.v(
1606                         TAG, "Reporting idle of " + a +
1607                         " finished=" +
1608                         (a.activity != null && a.activity.mFinished));
1609                     if (a.activity != null && !a.activity.mFinished) {
1610                         try {
1611                             am.activityIdle(a.token, a.createdConfig, stopProfiling);
1612                             a.createdConfig = null;
1613                         } catch (RemoteException ex) {
1614                             // Ignore
1615                         }
1616                     }
1617                     prev = a;
1618                     a = a.nextIdle;
1619                     prev.nextIdle = null;
1620                 } while (a != null);
1621             }
1622             if (stopProfiling) {
1623                 mProfiler.stopProfiling();
1624             }
1625             ensureJitEnabled();
1626             return false;
1627         }
1628     }
1629 
1630     final class GcIdler implements MessageQueue.IdleHandler {
1631         @Override
queueIdle()1632         public final boolean queueIdle() {
1633             doGcIfNeeded();
1634             return false;
1635         }
1636     }
1637 
currentActivityThread()1638     public static ActivityThread currentActivityThread() {
1639         return sCurrentActivityThread;
1640     }
1641 
isSystem()1642     public static boolean isSystem() {
1643         return (sCurrentActivityThread != null) ? sCurrentActivityThread.mSystemThread : false;
1644     }
1645 
currentOpPackageName()1646     public static String currentOpPackageName() {
1647         ActivityThread am = currentActivityThread();
1648         return (am != null && am.getApplication() != null)
1649                 ? am.getApplication().getOpPackageName() : null;
1650     }
1651 
currentPackageName()1652     public static String currentPackageName() {
1653         ActivityThread am = currentActivityThread();
1654         return (am != null && am.mBoundApplication != null)
1655             ? am.mBoundApplication.appInfo.packageName : null;
1656     }
1657 
currentProcessName()1658     public static String currentProcessName() {
1659         ActivityThread am = currentActivityThread();
1660         return (am != null && am.mBoundApplication != null)
1661             ? am.mBoundApplication.processName : null;
1662     }
1663 
currentApplication()1664     public static Application currentApplication() {
1665         ActivityThread am = currentActivityThread();
1666         return am != null ? am.mInitialApplication : null;
1667     }
1668 
getPackageManager()1669     public static IPackageManager getPackageManager() {
1670         if (sPackageManager != null) {
1671             //Slog.v("PackageManager", "returning cur default = " + sPackageManager);
1672             return sPackageManager;
1673         }
1674         IBinder b = ServiceManager.getService("package");
1675         //Slog.v("PackageManager", "default service binder = " + b);
1676         sPackageManager = IPackageManager.Stub.asInterface(b);
1677         //Slog.v("PackageManager", "default service = " + sPackageManager);
1678         return sPackageManager;
1679     }
1680 
1681     private Configuration mMainThreadConfig = new Configuration();
applyConfigCompatMainThread(int displayDensity, Configuration config, CompatibilityInfo compat)1682     Configuration applyConfigCompatMainThread(int displayDensity, Configuration config,
1683             CompatibilityInfo compat) {
1684         if (config == null) {
1685             return null;
1686         }
1687         if (!compat.supportsScreen()) {
1688             mMainThreadConfig.setTo(config);
1689             config = mMainThreadConfig;
1690             compat.applyToConfiguration(displayDensity, config);
1691         }
1692         return config;
1693     }
1694 
1695     /**
1696      * Creates the top level resources for the given package.
1697      */
getTopLevelResources(String resDir, String[] splitResDirs, String[] overlayDirs, String[] libDirs, int displayId, Configuration overrideConfiguration, LoadedApk pkgInfo)1698     Resources getTopLevelResources(String resDir, String[] splitResDirs, String[] overlayDirs,
1699             String[] libDirs, int displayId, Configuration overrideConfiguration,
1700             LoadedApk pkgInfo) {
1701         return mResourcesManager.getTopLevelResources(resDir, splitResDirs, overlayDirs, libDirs,
1702                 displayId, overrideConfiguration, pkgInfo.getCompatibilityInfo());
1703     }
1704 
getHandler()1705     final Handler getHandler() {
1706         return mH;
1707     }
1708 
getPackageInfo(String packageName, CompatibilityInfo compatInfo, int flags)1709     public final LoadedApk getPackageInfo(String packageName, CompatibilityInfo compatInfo,
1710             int flags) {
1711         return getPackageInfo(packageName, compatInfo, flags, UserHandle.myUserId());
1712     }
1713 
getPackageInfo(String packageName, CompatibilityInfo compatInfo, int flags, int userId)1714     public final LoadedApk getPackageInfo(String packageName, CompatibilityInfo compatInfo,
1715             int flags, int userId) {
1716         final boolean differentUser = (UserHandle.myUserId() != userId);
1717         synchronized (mResourcesManager) {
1718             WeakReference<LoadedApk> ref;
1719             if (differentUser) {
1720                 // Caching not supported across users
1721                 ref = null;
1722             } else if ((flags & Context.CONTEXT_INCLUDE_CODE) != 0) {
1723                 ref = mPackages.get(packageName);
1724             } else {
1725                 ref = mResourcePackages.get(packageName);
1726             }
1727 
1728             LoadedApk packageInfo = ref != null ? ref.get() : null;
1729             //Slog.i(TAG, "getPackageInfo " + packageName + ": " + packageInfo);
1730             //if (packageInfo != null) Slog.i(TAG, "isUptoDate " + packageInfo.mResDir
1731             //        + ": " + packageInfo.mResources.getAssets().isUpToDate());
1732             if (packageInfo != null && (packageInfo.mResources == null
1733                     || packageInfo.mResources.getAssets().isUpToDate())) {
1734                 if (packageInfo.isSecurityViolation()
1735                         && (flags&Context.CONTEXT_IGNORE_SECURITY) == 0) {
1736                     throw new SecurityException(
1737                             "Requesting code from " + packageName
1738                             + " to be run in process "
1739                             + mBoundApplication.processName
1740                             + "/" + mBoundApplication.appInfo.uid);
1741                 }
1742                 return packageInfo;
1743             }
1744         }
1745 
1746         ApplicationInfo ai = null;
1747         try {
1748             ai = getPackageManager().getApplicationInfo(packageName,
1749                     PackageManager.GET_SHARED_LIBRARY_FILES, userId);
1750         } catch (RemoteException e) {
1751             // Ignore
1752         }
1753 
1754         if (ai != null) {
1755             return getPackageInfo(ai, compatInfo, flags);
1756         }
1757 
1758         return null;
1759     }
1760 
getPackageInfo(ApplicationInfo ai, CompatibilityInfo compatInfo, int flags)1761     public final LoadedApk getPackageInfo(ApplicationInfo ai, CompatibilityInfo compatInfo,
1762             int flags) {
1763         boolean includeCode = (flags&Context.CONTEXT_INCLUDE_CODE) != 0;
1764         boolean securityViolation = includeCode && ai.uid != 0
1765                 && ai.uid != Process.SYSTEM_UID && (mBoundApplication != null
1766                         ? !UserHandle.isSameApp(ai.uid, mBoundApplication.appInfo.uid)
1767                         : true);
1768         boolean registerPackage = includeCode && (flags&Context.CONTEXT_REGISTER_PACKAGE) != 0;
1769         if ((flags&(Context.CONTEXT_INCLUDE_CODE
1770                 |Context.CONTEXT_IGNORE_SECURITY))
1771                 == Context.CONTEXT_INCLUDE_CODE) {
1772             if (securityViolation) {
1773                 String msg = "Requesting code from " + ai.packageName
1774                         + " (with uid " + ai.uid + ")";
1775                 if (mBoundApplication != null) {
1776                     msg = msg + " to be run in process "
1777                         + mBoundApplication.processName + " (with uid "
1778                         + mBoundApplication.appInfo.uid + ")";
1779                 }
1780                 throw new SecurityException(msg);
1781             }
1782         }
1783         return getPackageInfo(ai, compatInfo, null, securityViolation, includeCode,
1784                 registerPackage);
1785     }
1786 
getPackageInfoNoCheck(ApplicationInfo ai, CompatibilityInfo compatInfo)1787     public final LoadedApk getPackageInfoNoCheck(ApplicationInfo ai,
1788             CompatibilityInfo compatInfo) {
1789         return getPackageInfo(ai, compatInfo, null, false, true, false);
1790     }
1791 
peekPackageInfo(String packageName, boolean includeCode)1792     public final LoadedApk peekPackageInfo(String packageName, boolean includeCode) {
1793         synchronized (mResourcesManager) {
1794             WeakReference<LoadedApk> ref;
1795             if (includeCode) {
1796                 ref = mPackages.get(packageName);
1797             } else {
1798                 ref = mResourcePackages.get(packageName);
1799             }
1800             return ref != null ? ref.get() : null;
1801         }
1802     }
1803 
getPackageInfo(ApplicationInfo aInfo, CompatibilityInfo compatInfo, ClassLoader baseLoader, boolean securityViolation, boolean includeCode, boolean registerPackage)1804     private LoadedApk getPackageInfo(ApplicationInfo aInfo, CompatibilityInfo compatInfo,
1805             ClassLoader baseLoader, boolean securityViolation, boolean includeCode,
1806             boolean registerPackage) {
1807         final boolean differentUser = (UserHandle.myUserId() != UserHandle.getUserId(aInfo.uid));
1808         synchronized (mResourcesManager) {
1809             WeakReference<LoadedApk> ref;
1810             if (differentUser) {
1811                 // Caching not supported across users
1812                 ref = null;
1813             } else if (includeCode) {
1814                 ref = mPackages.get(aInfo.packageName);
1815             } else {
1816                 ref = mResourcePackages.get(aInfo.packageName);
1817             }
1818 
1819             LoadedApk packageInfo = ref != null ? ref.get() : null;
1820             if (packageInfo == null || (packageInfo.mResources != null
1821                     && !packageInfo.mResources.getAssets().isUpToDate())) {
1822                 if (localLOGV) Slog.v(TAG, (includeCode ? "Loading code package "
1823                         : "Loading resource-only package ") + aInfo.packageName
1824                         + " (in " + (mBoundApplication != null
1825                                 ? mBoundApplication.processName : null)
1826                         + ")");
1827                 packageInfo =
1828                     new LoadedApk(this, aInfo, compatInfo, baseLoader,
1829                             securityViolation, includeCode &&
1830                             (aInfo.flags&ApplicationInfo.FLAG_HAS_CODE) != 0, registerPackage);
1831 
1832                 if (mSystemThread && "android".equals(aInfo.packageName)) {
1833                     packageInfo.installSystemApplicationInfo(aInfo,
1834                             getSystemContext().mPackageInfo.getClassLoader());
1835                 }
1836 
1837                 if (differentUser) {
1838                     // Caching not supported across users
1839                 } else if (includeCode) {
1840                     mPackages.put(aInfo.packageName,
1841                             new WeakReference<LoadedApk>(packageInfo));
1842                 } else {
1843                     mResourcePackages.put(aInfo.packageName,
1844                             new WeakReference<LoadedApk>(packageInfo));
1845                 }
1846             }
1847             return packageInfo;
1848         }
1849     }
1850 
ActivityThread()1851     ActivityThread() {
1852         mResourcesManager = ResourcesManager.getInstance();
1853     }
1854 
getApplicationThread()1855     public ApplicationThread getApplicationThread()
1856     {
1857         return mAppThread;
1858     }
1859 
getInstrumentation()1860     public Instrumentation getInstrumentation()
1861     {
1862         return mInstrumentation;
1863     }
1864 
isProfiling()1865     public boolean isProfiling() {
1866         return mProfiler != null && mProfiler.profileFile != null
1867                 && mProfiler.profileFd == null;
1868     }
1869 
getProfileFilePath()1870     public String getProfileFilePath() {
1871         return mProfiler.profileFile;
1872     }
1873 
getLooper()1874     public Looper getLooper() {
1875         return mLooper;
1876     }
1877 
getApplication()1878     public Application getApplication() {
1879         return mInitialApplication;
1880     }
1881 
getProcessName()1882     public String getProcessName() {
1883         return mBoundApplication.processName;
1884     }
1885 
getSystemContext()1886     public ContextImpl getSystemContext() {
1887         synchronized (this) {
1888             if (mSystemContext == null) {
1889                 mSystemContext = ContextImpl.createSystemContext(this);
1890             }
1891             return mSystemContext;
1892         }
1893     }
1894 
installSystemApplicationInfo(ApplicationInfo info, ClassLoader classLoader)1895     public void installSystemApplicationInfo(ApplicationInfo info, ClassLoader classLoader) {
1896         synchronized (this) {
1897             getSystemContext().installSystemApplicationInfo(info, classLoader);
1898 
1899             // give ourselves a default profiler
1900             mProfiler = new Profiler();
1901         }
1902     }
1903 
ensureJitEnabled()1904     void ensureJitEnabled() {
1905         if (!mJitEnabled) {
1906             mJitEnabled = true;
1907             dalvik.system.VMRuntime.getRuntime().startJitCompilation();
1908         }
1909     }
1910 
scheduleGcIdler()1911     void scheduleGcIdler() {
1912         if (!mGcIdlerScheduled) {
1913             mGcIdlerScheduled = true;
1914             Looper.myQueue().addIdleHandler(mGcIdler);
1915         }
1916         mH.removeMessages(H.GC_WHEN_IDLE);
1917     }
1918 
unscheduleGcIdler()1919     void unscheduleGcIdler() {
1920         if (mGcIdlerScheduled) {
1921             mGcIdlerScheduled = false;
1922             Looper.myQueue().removeIdleHandler(mGcIdler);
1923         }
1924         mH.removeMessages(H.GC_WHEN_IDLE);
1925     }
1926 
doGcIfNeeded()1927     void doGcIfNeeded() {
1928         mGcIdlerScheduled = false;
1929         final long now = SystemClock.uptimeMillis();
1930         //Slog.i(TAG, "**** WE MIGHT WANT TO GC: then=" + Binder.getLastGcTime()
1931         //        + "m now=" + now);
1932         if ((BinderInternal.getLastGcTime()+MIN_TIME_BETWEEN_GCS) < now) {
1933             //Slog.i(TAG, "**** WE DO, WE DO WANT TO GC!");
1934             BinderInternal.forceGc("bg");
1935         }
1936     }
1937 
1938     private static final String HEAP_FULL_COLUMN
1939             = "%13s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s";
1940     private static final String HEAP_COLUMN
1941             = "%13s %8s %8s %8s %8s %8s %8s %8s";
1942     private static final String ONE_COUNT_COLUMN = "%21s %8d";
1943     private static final String TWO_COUNT_COLUMNS = "%21s %8d %21s %8d";
1944     private static final String ONE_COUNT_COLUMN_HEADER = "%21s %8s";
1945 
1946     // Formatting for checkin service - update version if row format changes
1947     private static final int ACTIVITY_THREAD_CHECKIN_VERSION = 3;
1948 
printRow(PrintWriter pw, String format, Object...objs)1949     static void printRow(PrintWriter pw, String format, Object...objs) {
1950         pw.println(String.format(format, objs));
1951     }
1952 
dumpMemInfoTable(PrintWriter pw, Debug.MemoryInfo memInfo, boolean checkin, boolean dumpFullInfo, boolean dumpDalvik, boolean dumpSummaryOnly, int pid, String processName, long nativeMax, long nativeAllocated, long nativeFree, long dalvikMax, long dalvikAllocated, long dalvikFree)1953     public static void dumpMemInfoTable(PrintWriter pw, Debug.MemoryInfo memInfo, boolean checkin,
1954             boolean dumpFullInfo, boolean dumpDalvik, boolean dumpSummaryOnly,
1955             int pid, String processName,
1956             long nativeMax, long nativeAllocated, long nativeFree,
1957             long dalvikMax, long dalvikAllocated, long dalvikFree) {
1958 
1959         // For checkin, we print one long comma-separated list of values
1960         if (checkin) {
1961             // NOTE: if you change anything significant below, also consider changing
1962             // ACTIVITY_THREAD_CHECKIN_VERSION.
1963 
1964             // Header
1965             pw.print(ACTIVITY_THREAD_CHECKIN_VERSION); pw.print(',');
1966             pw.print(pid); pw.print(',');
1967             pw.print(processName); pw.print(',');
1968 
1969             // Heap info - max
1970             pw.print(nativeMax); pw.print(',');
1971             pw.print(dalvikMax); pw.print(',');
1972             pw.print("N/A,");
1973             pw.print(nativeMax + dalvikMax); pw.print(',');
1974 
1975             // Heap info - allocated
1976             pw.print(nativeAllocated); pw.print(',');
1977             pw.print(dalvikAllocated); pw.print(',');
1978             pw.print("N/A,");
1979             pw.print(nativeAllocated + dalvikAllocated); pw.print(',');
1980 
1981             // Heap info - free
1982             pw.print(nativeFree); pw.print(',');
1983             pw.print(dalvikFree); pw.print(',');
1984             pw.print("N/A,");
1985             pw.print(nativeFree + dalvikFree); pw.print(',');
1986 
1987             // Heap info - proportional set size
1988             pw.print(memInfo.nativePss); pw.print(',');
1989             pw.print(memInfo.dalvikPss); pw.print(',');
1990             pw.print(memInfo.otherPss); pw.print(',');
1991             pw.print(memInfo.getTotalPss()); pw.print(',');
1992 
1993             // Heap info - swappable set size
1994             pw.print(memInfo.nativeSwappablePss); pw.print(',');
1995             pw.print(memInfo.dalvikSwappablePss); pw.print(',');
1996             pw.print(memInfo.otherSwappablePss); pw.print(',');
1997             pw.print(memInfo.getTotalSwappablePss()); pw.print(',');
1998 
1999             // Heap info - shared dirty
2000             pw.print(memInfo.nativeSharedDirty); pw.print(',');
2001             pw.print(memInfo.dalvikSharedDirty); pw.print(',');
2002             pw.print(memInfo.otherSharedDirty); pw.print(',');
2003             pw.print(memInfo.getTotalSharedDirty()); pw.print(',');
2004 
2005             // Heap info - shared clean
2006             pw.print(memInfo.nativeSharedClean); pw.print(',');
2007             pw.print(memInfo.dalvikSharedClean); pw.print(',');
2008             pw.print(memInfo.otherSharedClean); pw.print(',');
2009             pw.print(memInfo.getTotalSharedClean()); pw.print(',');
2010 
2011             // Heap info - private Dirty
2012             pw.print(memInfo.nativePrivateDirty); pw.print(',');
2013             pw.print(memInfo.dalvikPrivateDirty); pw.print(',');
2014             pw.print(memInfo.otherPrivateDirty); pw.print(',');
2015             pw.print(memInfo.getTotalPrivateDirty()); pw.print(',');
2016 
2017             // Heap info - private Clean
2018             pw.print(memInfo.nativePrivateClean); pw.print(',');
2019             pw.print(memInfo.dalvikPrivateClean); pw.print(',');
2020             pw.print(memInfo.otherPrivateClean); pw.print(',');
2021             pw.print(memInfo.getTotalPrivateClean()); pw.print(',');
2022 
2023             // Heap info - other areas
2024             for (int i=0; i<Debug.MemoryInfo.NUM_OTHER_STATS; i++) {
2025                 pw.print(Debug.MemoryInfo.getOtherLabel(i)); pw.print(',');
2026                 pw.print(memInfo.getOtherPss(i)); pw.print(',');
2027                 pw.print(memInfo.getOtherSwappablePss(i)); pw.print(',');
2028                 pw.print(memInfo.getOtherSharedDirty(i)); pw.print(',');
2029                 pw.print(memInfo.getOtherSharedClean(i)); pw.print(',');
2030                 pw.print(memInfo.getOtherPrivateDirty(i)); pw.print(',');
2031                 pw.print(memInfo.getOtherPrivateClean(i)); pw.print(',');
2032             }
2033             return;
2034         }
2035 
2036         if (!dumpSummaryOnly) {
2037             if (dumpFullInfo) {
2038                 printRow(pw, HEAP_FULL_COLUMN, "", "Pss", "Pss", "Shared", "Private",
2039                         "Shared", "Private", "Swapped", "Heap", "Heap", "Heap");
2040                 printRow(pw, HEAP_FULL_COLUMN, "", "Total", "Clean", "Dirty", "Dirty",
2041                         "Clean", "Clean", "Dirty", "Size", "Alloc", "Free");
2042                 printRow(pw, HEAP_FULL_COLUMN, "", "------", "------", "------", "------",
2043                         "------", "------", "------", "------", "------", "------");
2044                 printRow(pw, HEAP_FULL_COLUMN, "Native Heap", memInfo.nativePss,
2045                         memInfo.nativeSwappablePss, memInfo.nativeSharedDirty,
2046                         memInfo.nativePrivateDirty, memInfo.nativeSharedClean,
2047                         memInfo.nativePrivateClean, memInfo.nativeSwappedOut,
2048                         nativeMax, nativeAllocated, nativeFree);
2049                 printRow(pw, HEAP_FULL_COLUMN, "Dalvik Heap", memInfo.dalvikPss,
2050                         memInfo.dalvikSwappablePss, memInfo.dalvikSharedDirty,
2051                         memInfo.dalvikPrivateDirty, memInfo.dalvikSharedClean,
2052                         memInfo.dalvikPrivateClean, memInfo.dalvikSwappedOut,
2053                         dalvikMax, dalvikAllocated, dalvikFree);
2054             } else {
2055                 printRow(pw, HEAP_COLUMN, "", "Pss", "Private",
2056                         "Private", "Swapped", "Heap", "Heap", "Heap");
2057                 printRow(pw, HEAP_COLUMN, "", "Total", "Dirty",
2058                         "Clean", "Dirty", "Size", "Alloc", "Free");
2059                 printRow(pw, HEAP_COLUMN, "", "------", "------", "------",
2060                         "------", "------", "------", "------", "------");
2061                 printRow(pw, HEAP_COLUMN, "Native Heap", memInfo.nativePss,
2062                         memInfo.nativePrivateDirty,
2063                         memInfo.nativePrivateClean, memInfo.nativeSwappedOut,
2064                         nativeMax, nativeAllocated, nativeFree);
2065                 printRow(pw, HEAP_COLUMN, "Dalvik Heap", memInfo.dalvikPss,
2066                         memInfo.dalvikPrivateDirty,
2067                         memInfo.dalvikPrivateClean, memInfo.dalvikSwappedOut,
2068                         dalvikMax, dalvikAllocated, dalvikFree);
2069             }
2070 
2071             int otherPss = memInfo.otherPss;
2072             int otherSwappablePss = memInfo.otherSwappablePss;
2073             int otherSharedDirty = memInfo.otherSharedDirty;
2074             int otherPrivateDirty = memInfo.otherPrivateDirty;
2075             int otherSharedClean = memInfo.otherSharedClean;
2076             int otherPrivateClean = memInfo.otherPrivateClean;
2077             int otherSwappedOut = memInfo.otherSwappedOut;
2078 
2079             for (int i=0; i<Debug.MemoryInfo.NUM_OTHER_STATS; i++) {
2080                 final int myPss = memInfo.getOtherPss(i);
2081                 final int mySwappablePss = memInfo.getOtherSwappablePss(i);
2082                 final int mySharedDirty = memInfo.getOtherSharedDirty(i);
2083                 final int myPrivateDirty = memInfo.getOtherPrivateDirty(i);
2084                 final int mySharedClean = memInfo.getOtherSharedClean(i);
2085                 final int myPrivateClean = memInfo.getOtherPrivateClean(i);
2086                 final int mySwappedOut = memInfo.getOtherSwappedOut(i);
2087                 if (myPss != 0 || mySharedDirty != 0 || myPrivateDirty != 0
2088                         || mySharedClean != 0 || myPrivateClean != 0 || mySwappedOut != 0) {
2089                     if (dumpFullInfo) {
2090                         printRow(pw, HEAP_FULL_COLUMN, Debug.MemoryInfo.getOtherLabel(i),
2091                                 myPss, mySwappablePss, mySharedDirty, myPrivateDirty,
2092                                 mySharedClean, myPrivateClean, mySwappedOut, "", "", "");
2093                     } else {
2094                         printRow(pw, HEAP_COLUMN, Debug.MemoryInfo.getOtherLabel(i),
2095                                 myPss, myPrivateDirty,
2096                                 myPrivateClean, mySwappedOut, "", "", "");
2097                     }
2098                     otherPss -= myPss;
2099                     otherSwappablePss -= mySwappablePss;
2100                     otherSharedDirty -= mySharedDirty;
2101                     otherPrivateDirty -= myPrivateDirty;
2102                     otherSharedClean -= mySharedClean;
2103                     otherPrivateClean -= myPrivateClean;
2104                     otherSwappedOut -= mySwappedOut;
2105                 }
2106             }
2107 
2108             if (dumpFullInfo) {
2109                 printRow(pw, HEAP_FULL_COLUMN, "Unknown", otherPss, otherSwappablePss,
2110                         otherSharedDirty, otherPrivateDirty, otherSharedClean, otherPrivateClean,
2111                         otherSwappedOut, "", "", "");
2112                 printRow(pw, HEAP_FULL_COLUMN, "TOTAL", memInfo.getTotalPss(),
2113                         memInfo.getTotalSwappablePss(),
2114                         memInfo.getTotalSharedDirty(), memInfo.getTotalPrivateDirty(),
2115                         memInfo.getTotalSharedClean(), memInfo.getTotalPrivateClean(),
2116                         memInfo.getTotalSwappedOut(), nativeMax+dalvikMax,
2117                         nativeAllocated+dalvikAllocated, nativeFree+dalvikFree);
2118             } else {
2119                 printRow(pw, HEAP_COLUMN, "Unknown", otherPss,
2120                         otherPrivateDirty, otherPrivateClean, otherSwappedOut,
2121                         "", "", "");
2122                 printRow(pw, HEAP_COLUMN, "TOTAL", memInfo.getTotalPss(),
2123                         memInfo.getTotalPrivateDirty(),
2124                         memInfo.getTotalPrivateClean(),
2125                         memInfo.getTotalSwappedOut(),
2126                         nativeMax+dalvikMax,
2127                         nativeAllocated+dalvikAllocated, nativeFree+dalvikFree);
2128             }
2129 
2130             if (dumpDalvik) {
2131                 pw.println(" ");
2132                 pw.println(" Dalvik Details");
2133 
2134                 for (int i=Debug.MemoryInfo.NUM_OTHER_STATS;
2135                      i<Debug.MemoryInfo.NUM_OTHER_STATS + Debug.MemoryInfo.NUM_DVK_STATS; i++) {
2136                     final int myPss = memInfo.getOtherPss(i);
2137                     final int mySwappablePss = memInfo.getOtherSwappablePss(i);
2138                     final int mySharedDirty = memInfo.getOtherSharedDirty(i);
2139                     final int myPrivateDirty = memInfo.getOtherPrivateDirty(i);
2140                     final int mySharedClean = memInfo.getOtherSharedClean(i);
2141                     final int myPrivateClean = memInfo.getOtherPrivateClean(i);
2142                     final int mySwappedOut = memInfo.getOtherSwappedOut(i);
2143                     if (myPss != 0 || mySharedDirty != 0 || myPrivateDirty != 0
2144                             || mySharedClean != 0 || myPrivateClean != 0) {
2145                         if (dumpFullInfo) {
2146                             printRow(pw, HEAP_FULL_COLUMN, Debug.MemoryInfo.getOtherLabel(i),
2147                                     myPss, mySwappablePss, mySharedDirty, myPrivateDirty,
2148                                     mySharedClean, myPrivateClean, mySwappedOut, "", "", "");
2149                         } else {
2150                             printRow(pw, HEAP_COLUMN, Debug.MemoryInfo.getOtherLabel(i),
2151                                     myPss, myPrivateDirty,
2152                                     myPrivateClean, mySwappedOut, "", "", "");
2153                         }
2154                     }
2155                 }
2156             }
2157         }
2158 
2159         pw.println(" ");
2160         pw.println(" App Summary");
2161         printRow(pw, ONE_COUNT_COLUMN_HEADER, "", "Pss(KB)");
2162         printRow(pw, ONE_COUNT_COLUMN_HEADER, "", "------");
2163         printRow(pw, ONE_COUNT_COLUMN,
2164             "Java Heap:", memInfo.getSummaryJavaHeap());
2165         printRow(pw, ONE_COUNT_COLUMN,
2166             "Native Heap:", memInfo.getSummaryNativeHeap());
2167         printRow(pw, ONE_COUNT_COLUMN,
2168             "Code:", memInfo.getSummaryCode());
2169         printRow(pw, ONE_COUNT_COLUMN,
2170             "Stack:", memInfo.getSummaryStack());
2171         printRow(pw, ONE_COUNT_COLUMN,
2172             "Graphics:", memInfo.getSummaryGraphics());
2173         printRow(pw, ONE_COUNT_COLUMN,
2174             "Private Other:", memInfo.getSummaryPrivateOther());
2175         printRow(pw, ONE_COUNT_COLUMN,
2176             "System:", memInfo.getSummarySystem());
2177         pw.println(" ");
2178         printRow(pw, TWO_COUNT_COLUMNS,
2179             "TOTAL:", memInfo.getSummaryTotalPss(),
2180             "TOTAL SWAP (KB):", memInfo.getSummaryTotalSwap());
2181     }
2182 
registerOnActivityPausedListener(Activity activity, OnActivityPausedListener listener)2183     public void registerOnActivityPausedListener(Activity activity,
2184             OnActivityPausedListener listener) {
2185         synchronized (mOnPauseListeners) {
2186             ArrayList<OnActivityPausedListener> list = mOnPauseListeners.get(activity);
2187             if (list == null) {
2188                 list = new ArrayList<OnActivityPausedListener>();
2189                 mOnPauseListeners.put(activity, list);
2190             }
2191             list.add(listener);
2192         }
2193     }
2194 
unregisterOnActivityPausedListener(Activity activity, OnActivityPausedListener listener)2195     public void unregisterOnActivityPausedListener(Activity activity,
2196             OnActivityPausedListener listener) {
2197         synchronized (mOnPauseListeners) {
2198             ArrayList<OnActivityPausedListener> list = mOnPauseListeners.get(activity);
2199             if (list != null) {
2200                 list.remove(listener);
2201             }
2202         }
2203     }
2204 
resolveActivityInfo(Intent intent)2205     public final ActivityInfo resolveActivityInfo(Intent intent) {
2206         ActivityInfo aInfo = intent.resolveActivityInfo(
2207                 mInitialApplication.getPackageManager(), PackageManager.GET_SHARED_LIBRARY_FILES);
2208         if (aInfo == null) {
2209             // Throw an exception.
2210             Instrumentation.checkStartActivityResult(
2211                     ActivityManager.START_CLASS_NOT_FOUND, intent);
2212         }
2213         return aInfo;
2214     }
2215 
startActivityNow(Activity parent, String id, Intent intent, ActivityInfo activityInfo, IBinder token, Bundle state, Activity.NonConfigurationInstances lastNonConfigurationInstances)2216     public final Activity startActivityNow(Activity parent, String id,
2217         Intent intent, ActivityInfo activityInfo, IBinder token, Bundle state,
2218         Activity.NonConfigurationInstances lastNonConfigurationInstances) {
2219         ActivityClientRecord r = new ActivityClientRecord();
2220             r.token = token;
2221             r.ident = 0;
2222             r.intent = intent;
2223             r.state = state;
2224             r.parent = parent;
2225             r.embeddedID = id;
2226             r.activityInfo = activityInfo;
2227             r.lastNonConfigurationInstances = lastNonConfigurationInstances;
2228         if (localLOGV) {
2229             ComponentName compname = intent.getComponent();
2230             String name;
2231             if (compname != null) {
2232                 name = compname.toShortString();
2233             } else {
2234                 name = "(Intent " + intent + ").getComponent() returned null";
2235             }
2236             Slog.v(TAG, "Performing launch: action=" + intent.getAction()
2237                     + ", comp=" + name
2238                     + ", token=" + token);
2239         }
2240         return performLaunchActivity(r, null);
2241     }
2242 
getActivity(IBinder token)2243     public final Activity getActivity(IBinder token) {
2244         return mActivities.get(token).activity;
2245     }
2246 
sendActivityResult( IBinder token, String id, int requestCode, int resultCode, Intent data)2247     public final void sendActivityResult(
2248             IBinder token, String id, int requestCode,
2249             int resultCode, Intent data) {
2250         if (DEBUG_RESULTS) Slog.v(TAG, "sendActivityResult: id=" + id
2251                 + " req=" + requestCode + " res=" + resultCode + " data=" + data);
2252         ArrayList<ResultInfo> list = new ArrayList<ResultInfo>();
2253         list.add(new ResultInfo(id, requestCode, resultCode, data));
2254         mAppThread.scheduleSendResult(token, list);
2255     }
2256 
sendMessage(int what, Object obj)2257     private void sendMessage(int what, Object obj) {
2258         sendMessage(what, obj, 0, 0, false);
2259     }
2260 
sendMessage(int what, Object obj, int arg1)2261     private void sendMessage(int what, Object obj, int arg1) {
2262         sendMessage(what, obj, arg1, 0, false);
2263     }
2264 
sendMessage(int what, Object obj, int arg1, int arg2)2265     private void sendMessage(int what, Object obj, int arg1, int arg2) {
2266         sendMessage(what, obj, arg1, arg2, false);
2267     }
2268 
sendMessage(int what, Object obj, int arg1, int arg2, boolean async)2269     private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
2270         if (DEBUG_MESSAGES) Slog.v(
2271             TAG, "SCHEDULE " + what + " " + mH.codeToString(what)
2272             + ": " + arg1 + " / " + obj);
2273         Message msg = Message.obtain();
2274         msg.what = what;
2275         msg.obj = obj;
2276         msg.arg1 = arg1;
2277         msg.arg2 = arg2;
2278         if (async) {
2279             msg.setAsynchronous(true);
2280         }
2281         mH.sendMessage(msg);
2282     }
2283 
scheduleContextCleanup(ContextImpl context, String who, String what)2284     final void scheduleContextCleanup(ContextImpl context, String who,
2285             String what) {
2286         ContextCleanupInfo cci = new ContextCleanupInfo();
2287         cci.context = context;
2288         cci.who = who;
2289         cci.what = what;
2290         sendMessage(H.CLEAN_UP_CONTEXT, cci);
2291     }
2292 
performLaunchActivity(ActivityClientRecord r, Intent customIntent)2293     private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
2294         // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");
2295 
2296         ActivityInfo aInfo = r.activityInfo;
2297         if (r.packageInfo == null) {
2298             r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
2299                     Context.CONTEXT_INCLUDE_CODE);
2300         }
2301 
2302         ComponentName component = r.intent.getComponent();
2303         if (component == null) {
2304             component = r.intent.resolveActivity(
2305                 mInitialApplication.getPackageManager());
2306             r.intent.setComponent(component);
2307         }
2308 
2309         if (r.activityInfo.targetActivity != null) {
2310             component = new ComponentName(r.activityInfo.packageName,
2311                     r.activityInfo.targetActivity);
2312         }
2313 
2314         Activity activity = null;
2315         try {
2316             java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
2317             activity = mInstrumentation.newActivity(
2318                     cl, component.getClassName(), r.intent);
2319             StrictMode.incrementExpectedActivityCount(activity.getClass());
2320             r.intent.setExtrasClassLoader(cl);
2321             r.intent.prepareToEnterProcess();
2322             if (r.state != null) {
2323                 r.state.setClassLoader(cl);
2324             }
2325         } catch (Exception e) {
2326             if (!mInstrumentation.onException(activity, e)) {
2327                 throw new RuntimeException(
2328                     "Unable to instantiate activity " + component
2329                     + ": " + e.toString(), e);
2330             }
2331         }
2332 
2333         try {
2334             Application app = r.packageInfo.makeApplication(false, mInstrumentation);
2335 
2336             if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
2337             if (localLOGV) Slog.v(
2338                     TAG, r + ": app=" + app
2339                     + ", appName=" + app.getPackageName()
2340                     + ", pkg=" + r.packageInfo.getPackageName()
2341                     + ", comp=" + r.intent.getComponent().toShortString()
2342                     + ", dir=" + r.packageInfo.getAppDir());
2343 
2344             if (activity != null) {
2345                 Context appContext = createBaseContextForActivity(r, activity);
2346                 CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
2347                 Configuration config = new Configuration(mCompatConfiguration);
2348                 if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
2349                         + r.activityInfo.name + " with config " + config);
2350                 activity.attach(appContext, this, getInstrumentation(), r.token,
2351                         r.ident, app, r.intent, r.activityInfo, title, r.parent,
2352                         r.embeddedID, r.lastNonConfigurationInstances, config,
2353                         r.referrer, r.voiceInteractor);
2354 
2355                 if (customIntent != null) {
2356                     activity.mIntent = customIntent;
2357                 }
2358                 r.lastNonConfigurationInstances = null;
2359                 activity.mStartedActivity = false;
2360                 int theme = r.activityInfo.getThemeResource();
2361                 if (theme != 0) {
2362                     activity.setTheme(theme);
2363                 }
2364 
2365                 activity.mCalled = false;
2366                 if (r.isPersistable()) {
2367                     mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
2368                 } else {
2369                     mInstrumentation.callActivityOnCreate(activity, r.state);
2370                 }
2371                 if (!activity.mCalled) {
2372                     throw new SuperNotCalledException(
2373                         "Activity " + r.intent.getComponent().toShortString() +
2374                         " did not call through to super.onCreate()");
2375                 }
2376                 r.activity = activity;
2377                 r.stopped = true;
2378                 if (!r.activity.mFinished) {
2379                     activity.performStart();
2380                     r.stopped = false;
2381                 }
2382                 if (!r.activity.mFinished) {
2383                     if (r.isPersistable()) {
2384                         if (r.state != null || r.persistentState != null) {
2385                             mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
2386                                     r.persistentState);
2387                         }
2388                     } else if (r.state != null) {
2389                         mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
2390                     }
2391                 }
2392                 if (!r.activity.mFinished) {
2393                     activity.mCalled = false;
2394                     if (r.isPersistable()) {
2395                         mInstrumentation.callActivityOnPostCreate(activity, r.state,
2396                                 r.persistentState);
2397                     } else {
2398                         mInstrumentation.callActivityOnPostCreate(activity, r.state);
2399                     }
2400                     if (!activity.mCalled) {
2401                         throw new SuperNotCalledException(
2402                             "Activity " + r.intent.getComponent().toShortString() +
2403                             " did not call through to super.onPostCreate()");
2404                     }
2405                 }
2406             }
2407             r.paused = true;
2408 
2409             mActivities.put(r.token, r);
2410 
2411         } catch (SuperNotCalledException e) {
2412             throw e;
2413 
2414         } catch (Exception e) {
2415             if (!mInstrumentation.onException(activity, e)) {
2416                 throw new RuntimeException(
2417                     "Unable to start activity " + component
2418                     + ": " + e.toString(), e);
2419             }
2420         }
2421 
2422         return activity;
2423     }
2424 
createBaseContextForActivity(ActivityClientRecord r, final Activity activity)2425     private Context createBaseContextForActivity(ActivityClientRecord r, final Activity activity) {
2426         int displayId = Display.DEFAULT_DISPLAY;
2427         try {
2428             displayId = ActivityManagerNative.getDefault().getActivityDisplayId(r.token);
2429         } catch (RemoteException e) {
2430         }
2431 
2432         ContextImpl appContext = ContextImpl.createActivityContext(
2433                 this, r.packageInfo, displayId, r.overrideConfig);
2434         appContext.setOuterContext(activity);
2435         Context baseContext = appContext;
2436 
2437         final DisplayManagerGlobal dm = DisplayManagerGlobal.getInstance();
2438         // For debugging purposes, if the activity's package name contains the value of
2439         // the "debug.use-second-display" system property as a substring, then show
2440         // its content on a secondary display if there is one.
2441         String pkgName = SystemProperties.get("debug.second-display.pkg");
2442         if (pkgName != null && !pkgName.isEmpty()
2443                 && r.packageInfo.mPackageName.contains(pkgName)) {
2444             for (int id : dm.getDisplayIds()) {
2445                 if (id != Display.DEFAULT_DISPLAY) {
2446                     Display display =
2447                             dm.getCompatibleDisplay(id, appContext.getDisplayAdjustments(id));
2448                     baseContext = appContext.createDisplayContext(display);
2449                     break;
2450                 }
2451             }
2452         }
2453         return baseContext;
2454     }
2455 
handleLaunchActivity(ActivityClientRecord r, Intent customIntent)2456     private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
2457         // If we are getting ready to gc after going to the background, well
2458         // we are back active so skip it.
2459         unscheduleGcIdler();
2460         mSomeActivitiesChanged = true;
2461 
2462         if (r.profilerInfo != null) {
2463             mProfiler.setProfiler(r.profilerInfo);
2464             mProfiler.startProfiling();
2465         }
2466 
2467         // Make sure we are running with the most recent config.
2468         handleConfigurationChanged(null, null);
2469 
2470         if (localLOGV) Slog.v(
2471             TAG, "Handling launch of " + r);
2472 
2473         // Initialize before creating the activity
2474         WindowManagerGlobal.initialize();
2475 
2476         Activity a = performLaunchActivity(r, customIntent);
2477 
2478         if (a != null) {
2479             r.createdConfig = new Configuration(mConfiguration);
2480             Bundle oldState = r.state;
2481             handleResumeActivity(r.token, false, r.isForward,
2482                     !r.activity.mFinished && !r.startsNotResumed);
2483 
2484             if (!r.activity.mFinished && r.startsNotResumed) {
2485                 // The activity manager actually wants this one to start out
2486                 // paused, because it needs to be visible but isn't in the
2487                 // foreground.  We accomplish this by going through the
2488                 // normal startup (because activities expect to go through
2489                 // onResume() the first time they run, before their window
2490                 // is displayed), and then pausing it.  However, in this case
2491                 // we do -not- need to do the full pause cycle (of freezing
2492                 // and such) because the activity manager assumes it can just
2493                 // retain the current state it has.
2494                 try {
2495                     r.activity.mCalled = false;
2496                     mInstrumentation.callActivityOnPause(r.activity);
2497                     // We need to keep around the original state, in case
2498                     // we need to be created again.  But we only do this
2499                     // for pre-Honeycomb apps, which always save their state
2500                     // when pausing, so we can not have them save their state
2501                     // when restarting from a paused state.  For HC and later,
2502                     // we want to (and can) let the state be saved as the normal
2503                     // part of stopping the activity.
2504                     if (r.isPreHoneycomb()) {
2505                         r.state = oldState;
2506                     }
2507                     if (!r.activity.mCalled) {
2508                         throw new SuperNotCalledException(
2509                             "Activity " + r.intent.getComponent().toShortString() +
2510                             " did not call through to super.onPause()");
2511                     }
2512 
2513                 } catch (SuperNotCalledException e) {
2514                     throw e;
2515 
2516                 } catch (Exception e) {
2517                     if (!mInstrumentation.onException(r.activity, e)) {
2518                         throw new RuntimeException(
2519                                 "Unable to pause activity "
2520                                 + r.intent.getComponent().toShortString()
2521                                 + ": " + e.toString(), e);
2522                     }
2523                 }
2524                 r.paused = true;
2525             }
2526         } else {
2527             // If there was an error, for any reason, tell the activity
2528             // manager to stop us.
2529             try {
2530                 ActivityManagerNative.getDefault()
2531                     .finishActivity(r.token, Activity.RESULT_CANCELED, null, false);
2532             } catch (RemoteException ex) {
2533                 // Ignore
2534             }
2535         }
2536     }
2537 
deliverNewIntents(ActivityClientRecord r, List<ReferrerIntent> intents)2538     private void deliverNewIntents(ActivityClientRecord r, List<ReferrerIntent> intents) {
2539         final int N = intents.size();
2540         for (int i=0; i<N; i++) {
2541             ReferrerIntent intent = intents.get(i);
2542             intent.setExtrasClassLoader(r.activity.getClassLoader());
2543             intent.prepareToEnterProcess();
2544             r.activity.mFragments.noteStateNotSaved();
2545             mInstrumentation.callActivityOnNewIntent(r.activity, intent);
2546         }
2547     }
2548 
performNewIntents(IBinder token, List<ReferrerIntent> intents)2549     public final void performNewIntents(IBinder token, List<ReferrerIntent> intents) {
2550         ActivityClientRecord r = mActivities.get(token);
2551         if (r != null) {
2552             final boolean resumed = !r.paused;
2553             if (resumed) {
2554                 r.activity.mTemporaryPause = true;
2555                 mInstrumentation.callActivityOnPause(r.activity);
2556             }
2557             deliverNewIntents(r, intents);
2558             if (resumed) {
2559                 r.activity.performResume();
2560                 r.activity.mTemporaryPause = false;
2561             }
2562         }
2563     }
2564 
handleNewIntent(NewIntentData data)2565     private void handleNewIntent(NewIntentData data) {
2566         performNewIntents(data.token, data.intents);
2567     }
2568 
handleRequestAssistContextExtras(RequestAssistContextExtras cmd)2569     public void handleRequestAssistContextExtras(RequestAssistContextExtras cmd) {
2570         if (mLastAssistStructure != null) {
2571             AssistStructure structure = mLastAssistStructure.get();
2572             if (structure != null) {
2573                 structure.clearSendChannel();
2574             }
2575         }
2576         Bundle data = new Bundle();
2577         AssistStructure structure = null;
2578         AssistContent content = new AssistContent();
2579         ActivityClientRecord r = mActivities.get(cmd.activityToken);
2580         Uri referrer = null;
2581         if (r != null) {
2582             r.activity.getApplication().dispatchOnProvideAssistData(r.activity, data);
2583             r.activity.onProvideAssistData(data);
2584             referrer = r.activity.onProvideReferrer();
2585             if (cmd.requestType == ActivityManager.ASSIST_CONTEXT_FULL) {
2586                 structure = new AssistStructure(r.activity);
2587                 Intent activityIntent = r.activity.getIntent();
2588                 if (activityIntent != null && (r.window == null ||
2589                         (r.window.getAttributes().flags
2590                                 & WindowManager.LayoutParams.FLAG_SECURE) == 0)) {
2591                     Intent intent = new Intent(activityIntent);
2592                     intent.setFlags(intent.getFlags() & ~(Intent.FLAG_GRANT_WRITE_URI_PERMISSION
2593                             | Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION));
2594                     intent.removeUnsafeExtras();
2595                     content.setDefaultIntent(intent);
2596                 } else {
2597                     content.setDefaultIntent(new Intent());
2598                 }
2599                 r.activity.onProvideAssistContent(content);
2600             }
2601         }
2602         if (structure == null) {
2603             structure = new AssistStructure();
2604         }
2605         mLastAssistStructure = new WeakReference<>(structure);
2606         IActivityManager mgr = ActivityManagerNative.getDefault();
2607         try {
2608             mgr.reportAssistContextExtras(cmd.requestToken, data, structure, content, referrer);
2609         } catch (RemoteException e) {
2610         }
2611     }
2612 
handleTranslucentConversionComplete(IBinder token, boolean drawComplete)2613     public void handleTranslucentConversionComplete(IBinder token, boolean drawComplete) {
2614         ActivityClientRecord r = mActivities.get(token);
2615         if (r != null) {
2616             r.activity.onTranslucentConversionComplete(drawComplete);
2617         }
2618     }
2619 
onNewActivityOptions(IBinder token, ActivityOptions options)2620     public void onNewActivityOptions(IBinder token, ActivityOptions options) {
2621         ActivityClientRecord r = mActivities.get(token);
2622         if (r != null) {
2623             r.activity.onNewActivityOptions(options);
2624         }
2625     }
2626 
handleCancelVisibleBehind(IBinder token)2627     public void handleCancelVisibleBehind(IBinder token) {
2628         ActivityClientRecord r = mActivities.get(token);
2629         if (r != null) {
2630             mSomeActivitiesChanged = true;
2631             final Activity activity = r.activity;
2632             if (activity.mVisibleBehind) {
2633                 activity.mCalled = false;
2634                 activity.onVisibleBehindCanceled();
2635                 // Tick, tick, tick. The activity has 500 msec to return or it will be destroyed.
2636                 if (!activity.mCalled) {
2637                     throw new SuperNotCalledException("Activity " + activity.getLocalClassName() +
2638                             " did not call through to super.onVisibleBehindCanceled()");
2639                 }
2640                 activity.mVisibleBehind = false;
2641             }
2642         }
2643         try {
2644             ActivityManagerNative.getDefault().backgroundResourcesReleased(token);
2645         } catch (RemoteException e) {
2646         }
2647     }
2648 
handleOnBackgroundVisibleBehindChanged(IBinder token, boolean visible)2649     public void handleOnBackgroundVisibleBehindChanged(IBinder token, boolean visible) {
2650         ActivityClientRecord r = mActivities.get(token);
2651         if (r != null) {
2652             r.activity.onBackgroundVisibleBehindChanged(visible);
2653         }
2654     }
2655 
handleInstallProvider(ProviderInfo info)2656     public void handleInstallProvider(ProviderInfo info) {
2657         final StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
2658         try {
2659             installContentProviders(mInitialApplication, Lists.newArrayList(info));
2660         } finally {
2661             StrictMode.setThreadPolicy(oldPolicy);
2662         }
2663     }
2664 
handleEnterAnimationComplete(IBinder token)2665     private void handleEnterAnimationComplete(IBinder token) {
2666         ActivityClientRecord r = mActivities.get(token);
2667         if (r != null) {
2668             r.activity.dispatchEnterAnimationComplete();
2669         }
2670     }
2671 
2672     private static final ThreadLocal<Intent> sCurrentBroadcastIntent = new ThreadLocal<Intent>();
2673 
2674     /**
2675      * Return the Intent that's currently being handled by a
2676      * BroadcastReceiver on this thread, or null if none.
2677      * @hide
2678      */
getIntentBeingBroadcast()2679     public static Intent getIntentBeingBroadcast() {
2680         return sCurrentBroadcastIntent.get();
2681     }
2682 
handleReceiver(ReceiverData data)2683     private void handleReceiver(ReceiverData data) {
2684         // If we are getting ready to gc after going to the background, well
2685         // we are back active so skip it.
2686         unscheduleGcIdler();
2687 
2688         String component = data.intent.getComponent().getClassName();
2689 
2690         LoadedApk packageInfo = getPackageInfoNoCheck(
2691                 data.info.applicationInfo, data.compatInfo);
2692 
2693         IActivityManager mgr = ActivityManagerNative.getDefault();
2694 
2695         BroadcastReceiver receiver;
2696         try {
2697             java.lang.ClassLoader cl = packageInfo.getClassLoader();
2698             data.intent.setExtrasClassLoader(cl);
2699             data.intent.prepareToEnterProcess();
2700             data.setExtrasClassLoader(cl);
2701             receiver = (BroadcastReceiver)cl.loadClass(component).newInstance();
2702         } catch (Exception e) {
2703             if (DEBUG_BROADCAST) Slog.i(TAG,
2704                     "Finishing failed broadcast to " + data.intent.getComponent());
2705             data.sendFinished(mgr);
2706             throw new RuntimeException(
2707                 "Unable to instantiate receiver " + component
2708                 + ": " + e.toString(), e);
2709         }
2710 
2711         try {
2712             Application app = packageInfo.makeApplication(false, mInstrumentation);
2713 
2714             if (localLOGV) Slog.v(
2715                 TAG, "Performing receive of " + data.intent
2716                 + ": app=" + app
2717                 + ", appName=" + app.getPackageName()
2718                 + ", pkg=" + packageInfo.getPackageName()
2719                 + ", comp=" + data.intent.getComponent().toShortString()
2720                 + ", dir=" + packageInfo.getAppDir());
2721 
2722             ContextImpl context = (ContextImpl)app.getBaseContext();
2723             sCurrentBroadcastIntent.set(data.intent);
2724             receiver.setPendingResult(data);
2725             receiver.onReceive(context.getReceiverRestrictedContext(),
2726                     data.intent);
2727         } catch (Exception e) {
2728             if (DEBUG_BROADCAST) Slog.i(TAG,
2729                     "Finishing failed broadcast to " + data.intent.getComponent());
2730             data.sendFinished(mgr);
2731             if (!mInstrumentation.onException(receiver, e)) {
2732                 throw new RuntimeException(
2733                     "Unable to start receiver " + component
2734                     + ": " + e.toString(), e);
2735             }
2736         } finally {
2737             sCurrentBroadcastIntent.set(null);
2738         }
2739 
2740         if (receiver.getPendingResult() != null) {
2741             data.finish();
2742         }
2743     }
2744 
2745     // Instantiate a BackupAgent and tell it that it's alive
handleCreateBackupAgent(CreateBackupAgentData data)2746     private void handleCreateBackupAgent(CreateBackupAgentData data) {
2747         if (DEBUG_BACKUP) Slog.v(TAG, "handleCreateBackupAgent: " + data);
2748 
2749         // Sanity check the requested target package's uid against ours
2750         try {
2751             PackageInfo requestedPackage = getPackageManager().getPackageInfo(
2752                     data.appInfo.packageName, 0, UserHandle.myUserId());
2753             if (requestedPackage.applicationInfo.uid != Process.myUid()) {
2754                 Slog.w(TAG, "Asked to instantiate non-matching package "
2755                         + data.appInfo.packageName);
2756                 return;
2757             }
2758         } catch (RemoteException e) {
2759             Slog.e(TAG, "Can't reach package manager", e);
2760             return;
2761         }
2762 
2763         // no longer idle; we have backup work to do
2764         unscheduleGcIdler();
2765 
2766         // instantiate the BackupAgent class named in the manifest
2767         LoadedApk packageInfo = getPackageInfoNoCheck(data.appInfo, data.compatInfo);
2768         String packageName = packageInfo.mPackageName;
2769         if (packageName == null) {
2770             Slog.d(TAG, "Asked to create backup agent for nonexistent package");
2771             return;
2772         }
2773 
2774         String classname = data.appInfo.backupAgentName;
2775         // full backup operation but no app-supplied agent?  use the default implementation
2776         if (classname == null && (data.backupMode == IApplicationThread.BACKUP_MODE_FULL
2777                 || data.backupMode == IApplicationThread.BACKUP_MODE_RESTORE_FULL)) {
2778             classname = "android.app.backup.FullBackupAgent";
2779         }
2780 
2781         try {
2782             IBinder binder = null;
2783             BackupAgent agent = mBackupAgents.get(packageName);
2784             if (agent != null) {
2785                 // reusing the existing instance
2786                 if (DEBUG_BACKUP) {
2787                     Slog.v(TAG, "Reusing existing agent instance");
2788                 }
2789                 binder = agent.onBind();
2790             } else {
2791                 try {
2792                     if (DEBUG_BACKUP) Slog.v(TAG, "Initializing agent class " + classname);
2793 
2794                     java.lang.ClassLoader cl = packageInfo.getClassLoader();
2795                     agent = (BackupAgent) cl.loadClass(classname).newInstance();
2796 
2797                     // set up the agent's context
2798                     ContextImpl context = ContextImpl.createAppContext(this, packageInfo);
2799                     context.setOuterContext(agent);
2800                     agent.attach(context);
2801 
2802                     agent.onCreate();
2803                     binder = agent.onBind();
2804                     mBackupAgents.put(packageName, agent);
2805                 } catch (Exception e) {
2806                     // If this is during restore, fail silently; otherwise go
2807                     // ahead and let the user see the crash.
2808                     Slog.e(TAG, "Agent threw during creation: " + e);
2809                     if (data.backupMode != IApplicationThread.BACKUP_MODE_RESTORE
2810                             && data.backupMode != IApplicationThread.BACKUP_MODE_RESTORE_FULL) {
2811                         throw e;
2812                     }
2813                     // falling through with 'binder' still null
2814                 }
2815             }
2816 
2817             // tell the OS that we're live now
2818             try {
2819                 ActivityManagerNative.getDefault().backupAgentCreated(packageName, binder);
2820             } catch (RemoteException e) {
2821                 // nothing to do.
2822             }
2823         } catch (Exception e) {
2824             throw new RuntimeException("Unable to create BackupAgent "
2825                     + classname + ": " + e.toString(), e);
2826         }
2827     }
2828 
2829     // Tear down a BackupAgent
handleDestroyBackupAgent(CreateBackupAgentData data)2830     private void handleDestroyBackupAgent(CreateBackupAgentData data) {
2831         if (DEBUG_BACKUP) Slog.v(TAG, "handleDestroyBackupAgent: " + data);
2832 
2833         LoadedApk packageInfo = getPackageInfoNoCheck(data.appInfo, data.compatInfo);
2834         String packageName = packageInfo.mPackageName;
2835         BackupAgent agent = mBackupAgents.get(packageName);
2836         if (agent != null) {
2837             try {
2838                 agent.onDestroy();
2839             } catch (Exception e) {
2840                 Slog.w(TAG, "Exception thrown in onDestroy by backup agent of " + data.appInfo);
2841                 e.printStackTrace();
2842             }
2843             mBackupAgents.remove(packageName);
2844         } else {
2845             Slog.w(TAG, "Attempt to destroy unknown backup agent " + data);
2846         }
2847     }
2848 
handleCreateService(CreateServiceData data)2849     private void handleCreateService(CreateServiceData data) {
2850         // If we are getting ready to gc after going to the background, well
2851         // we are back active so skip it.
2852         unscheduleGcIdler();
2853 
2854         LoadedApk packageInfo = getPackageInfoNoCheck(
2855                 data.info.applicationInfo, data.compatInfo);
2856         Service service = null;
2857         try {
2858             java.lang.ClassLoader cl = packageInfo.getClassLoader();
2859             service = (Service) cl.loadClass(data.info.name).newInstance();
2860         } catch (Exception e) {
2861             if (!mInstrumentation.onException(service, e)) {
2862                 throw new RuntimeException(
2863                     "Unable to instantiate service " + data.info.name
2864                     + ": " + e.toString(), e);
2865             }
2866         }
2867 
2868         try {
2869             if (localLOGV) Slog.v(TAG, "Creating service " + data.info.name);
2870 
2871             ContextImpl context = ContextImpl.createAppContext(this, packageInfo);
2872             context.setOuterContext(service);
2873 
2874             Application app = packageInfo.makeApplication(false, mInstrumentation);
2875             service.attach(context, this, data.info.name, data.token, app,
2876                     ActivityManagerNative.getDefault());
2877             service.onCreate();
2878             mServices.put(data.token, service);
2879             try {
2880                 ActivityManagerNative.getDefault().serviceDoneExecuting(
2881                         data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
2882             } catch (RemoteException e) {
2883                 // nothing to do.
2884             }
2885         } catch (Exception e) {
2886             if (!mInstrumentation.onException(service, e)) {
2887                 throw new RuntimeException(
2888                     "Unable to create service " + data.info.name
2889                     + ": " + e.toString(), e);
2890             }
2891         }
2892     }
2893 
handleBindService(BindServiceData data)2894     private void handleBindService(BindServiceData data) {
2895         Service s = mServices.get(data.token);
2896         if (DEBUG_SERVICE)
2897             Slog.v(TAG, "handleBindService s=" + s + " rebind=" + data.rebind);
2898         if (s != null) {
2899             try {
2900                 data.intent.setExtrasClassLoader(s.getClassLoader());
2901                 data.intent.prepareToEnterProcess();
2902                 try {
2903                     if (!data.rebind) {
2904                         IBinder binder = s.onBind(data.intent);
2905                         ActivityManagerNative.getDefault().publishService(
2906                                 data.token, data.intent, binder);
2907                     } else {
2908                         s.onRebind(data.intent);
2909                         ActivityManagerNative.getDefault().serviceDoneExecuting(
2910                                 data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
2911                     }
2912                     ensureJitEnabled();
2913                 } catch (RemoteException ex) {
2914                 }
2915             } catch (Exception e) {
2916                 if (!mInstrumentation.onException(s, e)) {
2917                     throw new RuntimeException(
2918                             "Unable to bind to service " + s
2919                             + " with " + data.intent + ": " + e.toString(), e);
2920                 }
2921             }
2922         }
2923     }
2924 
handleUnbindService(BindServiceData data)2925     private void handleUnbindService(BindServiceData data) {
2926         Service s = mServices.get(data.token);
2927         if (s != null) {
2928             try {
2929                 data.intent.setExtrasClassLoader(s.getClassLoader());
2930                 data.intent.prepareToEnterProcess();
2931                 boolean doRebind = s.onUnbind(data.intent);
2932                 try {
2933                     if (doRebind) {
2934                         ActivityManagerNative.getDefault().unbindFinished(
2935                                 data.token, data.intent, doRebind);
2936                     } else {
2937                         ActivityManagerNative.getDefault().serviceDoneExecuting(
2938                                 data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
2939                     }
2940                 } catch (RemoteException ex) {
2941                 }
2942             } catch (Exception e) {
2943                 if (!mInstrumentation.onException(s, e)) {
2944                     throw new RuntimeException(
2945                             "Unable to unbind to service " + s
2946                             + " with " + data.intent + ": " + e.toString(), e);
2947                 }
2948             }
2949         }
2950     }
2951 
handleDumpService(DumpComponentInfo info)2952     private void handleDumpService(DumpComponentInfo info) {
2953         final StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
2954         try {
2955             Service s = mServices.get(info.token);
2956             if (s != null) {
2957                 PrintWriter pw = new FastPrintWriter(new FileOutputStream(
2958                         info.fd.getFileDescriptor()));
2959                 s.dump(info.fd.getFileDescriptor(), pw, info.args);
2960                 pw.flush();
2961             }
2962         } finally {
2963             IoUtils.closeQuietly(info.fd);
2964             StrictMode.setThreadPolicy(oldPolicy);
2965         }
2966     }
2967 
handleDumpActivity(DumpComponentInfo info)2968     private void handleDumpActivity(DumpComponentInfo info) {
2969         final StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
2970         try {
2971             ActivityClientRecord r = mActivities.get(info.token);
2972             if (r != null && r.activity != null) {
2973                 PrintWriter pw = new FastPrintWriter(new FileOutputStream(
2974                         info.fd.getFileDescriptor()));
2975                 r.activity.dump(info.prefix, info.fd.getFileDescriptor(), pw, info.args);
2976                 pw.flush();
2977             }
2978         } finally {
2979             IoUtils.closeQuietly(info.fd);
2980             StrictMode.setThreadPolicy(oldPolicy);
2981         }
2982     }
2983 
handleDumpProvider(DumpComponentInfo info)2984     private void handleDumpProvider(DumpComponentInfo info) {
2985         final StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
2986         try {
2987             ProviderClientRecord r = mLocalProviders.get(info.token);
2988             if (r != null && r.mLocalProvider != null) {
2989                 PrintWriter pw = new FastPrintWriter(new FileOutputStream(
2990                         info.fd.getFileDescriptor()));
2991                 r.mLocalProvider.dump(info.fd.getFileDescriptor(), pw, info.args);
2992                 pw.flush();
2993             }
2994         } finally {
2995             IoUtils.closeQuietly(info.fd);
2996             StrictMode.setThreadPolicy(oldPolicy);
2997         }
2998     }
2999 
handleServiceArgs(ServiceArgsData data)3000     private void handleServiceArgs(ServiceArgsData data) {
3001         Service s = mServices.get(data.token);
3002         if (s != null) {
3003             try {
3004                 if (data.args != null) {
3005                     data.args.setExtrasClassLoader(s.getClassLoader());
3006                     data.args.prepareToEnterProcess();
3007                 }
3008                 int res;
3009                 if (!data.taskRemoved) {
3010                     res = s.onStartCommand(data.args, data.flags, data.startId);
3011                 } else {
3012                     s.onTaskRemoved(data.args);
3013                     res = Service.START_TASK_REMOVED_COMPLETE;
3014                 }
3015 
3016                 QueuedWork.waitToFinish();
3017 
3018                 try {
3019                     ActivityManagerNative.getDefault().serviceDoneExecuting(
3020                             data.token, SERVICE_DONE_EXECUTING_START, data.startId, res);
3021                 } catch (RemoteException e) {
3022                     // nothing to do.
3023                 }
3024                 ensureJitEnabled();
3025             } catch (Exception e) {
3026                 if (!mInstrumentation.onException(s, e)) {
3027                     throw new RuntimeException(
3028                             "Unable to start service " + s
3029                             + " with " + data.args + ": " + e.toString(), e);
3030                 }
3031             }
3032         }
3033     }
3034 
handleStopService(IBinder token)3035     private void handleStopService(IBinder token) {
3036         Service s = mServices.remove(token);
3037         if (s != null) {
3038             try {
3039                 if (localLOGV) Slog.v(TAG, "Destroying service " + s);
3040                 s.onDestroy();
3041                 Context context = s.getBaseContext();
3042                 if (context instanceof ContextImpl) {
3043                     final String who = s.getClassName();
3044                     ((ContextImpl) context).scheduleFinalCleanup(who, "Service");
3045                 }
3046 
3047                 QueuedWork.waitToFinish();
3048 
3049                 try {
3050                     ActivityManagerNative.getDefault().serviceDoneExecuting(
3051                             token, SERVICE_DONE_EXECUTING_STOP, 0, 0);
3052                 } catch (RemoteException e) {
3053                     // nothing to do.
3054                     Slog.i(TAG, "handleStopService: unable to execute serviceDoneExecuting for "
3055                             + token, e);
3056                 }
3057             } catch (Exception e) {
3058                 if (!mInstrumentation.onException(s, e)) {
3059                     throw new RuntimeException(
3060                             "Unable to stop service " + s
3061                             + ": " + e.toString(), e);
3062                 }
3063                 Slog.i(TAG, "handleStopService: exception for " + token, e);
3064             }
3065         } else {
3066             Slog.i(TAG, "handleStopService: token=" + token + " not found.");
3067         }
3068         //Slog.i(TAG, "Running services: " + mServices);
3069     }
3070 
performResumeActivity(IBinder token, boolean clearHide)3071     public final ActivityClientRecord performResumeActivity(IBinder token,
3072             boolean clearHide) {
3073         ActivityClientRecord r = mActivities.get(token);
3074         if (localLOGV) Slog.v(TAG, "Performing resume of " + r
3075                 + " finished=" + r.activity.mFinished);
3076         if (r != null && !r.activity.mFinished) {
3077             if (clearHide) {
3078                 r.hideForNow = false;
3079                 r.activity.mStartedActivity = false;
3080             }
3081             try {
3082                 r.activity.onStateNotSaved();
3083                 r.activity.mFragments.noteStateNotSaved();
3084                 if (r.pendingIntents != null) {
3085                     deliverNewIntents(r, r.pendingIntents);
3086                     r.pendingIntents = null;
3087                 }
3088                 if (r.pendingResults != null) {
3089                     deliverResults(r, r.pendingResults);
3090                     r.pendingResults = null;
3091                 }
3092                 r.activity.performResume();
3093 
3094                 EventLog.writeEvent(LOG_AM_ON_RESUME_CALLED,
3095                         UserHandle.myUserId(), r.activity.getComponentName().getClassName());
3096 
3097                 r.paused = false;
3098                 r.stopped = false;
3099                 r.state = null;
3100                 r.persistentState = null;
3101             } catch (Exception e) {
3102                 if (!mInstrumentation.onException(r.activity, e)) {
3103                     throw new RuntimeException(
3104                         "Unable to resume activity "
3105                         + r.intent.getComponent().toShortString()
3106                         + ": " + e.toString(), e);
3107                 }
3108             }
3109         }
3110         return r;
3111     }
3112 
cleanUpPendingRemoveWindows(ActivityClientRecord r)3113     static final void cleanUpPendingRemoveWindows(ActivityClientRecord r) {
3114         if (r.mPendingRemoveWindow != null) {
3115             r.mPendingRemoveWindowManager.removeViewImmediate(r.mPendingRemoveWindow);
3116             IBinder wtoken = r.mPendingRemoveWindow.getWindowToken();
3117             if (wtoken != null) {
3118                 WindowManagerGlobal.getInstance().closeAll(wtoken,
3119                         r.activity.getClass().getName(), "Activity");
3120             }
3121         }
3122         r.mPendingRemoveWindow = null;
3123         r.mPendingRemoveWindowManager = null;
3124     }
3125 
handleResumeActivity(IBinder token, boolean clearHide, boolean isForward, boolean reallyResume)3126     final void handleResumeActivity(IBinder token,
3127             boolean clearHide, boolean isForward, boolean reallyResume) {
3128         // If we are getting ready to gc after going to the background, well
3129         // we are back active so skip it.
3130         unscheduleGcIdler();
3131         mSomeActivitiesChanged = true;
3132 
3133         // TODO Push resumeArgs into the activity for consideration
3134         ActivityClientRecord r = performResumeActivity(token, clearHide);
3135 
3136         if (r != null) {
3137             final Activity a = r.activity;
3138 
3139             if (localLOGV) Slog.v(
3140                 TAG, "Resume " + r + " started activity: " +
3141                 a.mStartedActivity + ", hideForNow: " + r.hideForNow
3142                 + ", finished: " + a.mFinished);
3143 
3144             final int forwardBit = isForward ?
3145                     WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;
3146 
3147             // If the window hasn't yet been added to the window manager,
3148             // and this guy didn't finish itself or start another activity,
3149             // then go ahead and add the window.
3150             boolean willBeVisible = !a.mStartedActivity;
3151             if (!willBeVisible) {
3152                 try {
3153                     willBeVisible = ActivityManagerNative.getDefault().willActivityBeVisible(
3154                             a.getActivityToken());
3155                 } catch (RemoteException e) {
3156                 }
3157             }
3158             if (r.window == null && !a.mFinished && willBeVisible) {
3159                 r.window = r.activity.getWindow();
3160                 View decor = r.window.getDecorView();
3161                 decor.setVisibility(View.INVISIBLE);
3162                 ViewManager wm = a.getWindowManager();
3163                 WindowManager.LayoutParams l = r.window.getAttributes();
3164                 a.mDecor = decor;
3165                 l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
3166                 l.softInputMode |= forwardBit;
3167                 if (a.mVisibleFromClient) {
3168                     a.mWindowAdded = true;
3169                     wm.addView(decor, l);
3170                 }
3171 
3172             // If the window has already been added, but during resume
3173             // we started another activity, then don't yet make the
3174             // window visible.
3175             } else if (!willBeVisible) {
3176                 if (localLOGV) Slog.v(
3177                     TAG, "Launch " + r + " mStartedActivity set");
3178                 r.hideForNow = true;
3179             }
3180 
3181             // Get rid of anything left hanging around.
3182             cleanUpPendingRemoveWindows(r);
3183 
3184             // The window is now visible if it has been added, we are not
3185             // simply finishing, and we are not starting another activity.
3186             if (!r.activity.mFinished && willBeVisible
3187                     && r.activity.mDecor != null && !r.hideForNow) {
3188                 if (r.newConfig != null) {
3189                     r.tmpConfig.setTo(r.newConfig);
3190                     if (r.overrideConfig != null) {
3191                         r.tmpConfig.updateFrom(r.overrideConfig);
3192                     }
3193                     if (DEBUG_CONFIGURATION) Slog.v(TAG, "Resuming activity "
3194                             + r.activityInfo.name + " with newConfig " + r.tmpConfig);
3195                     performConfigurationChanged(r.activity, r.tmpConfig);
3196                     freeTextLayoutCachesIfNeeded(r.activity.mCurrentConfig.diff(r.tmpConfig));
3197                     r.newConfig = null;
3198                 }
3199                 if (localLOGV) Slog.v(TAG, "Resuming " + r + " with isForward="
3200                         + isForward);
3201                 WindowManager.LayoutParams l = r.window.getAttributes();
3202                 if ((l.softInputMode
3203                         & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION)
3204                         != forwardBit) {
3205                     l.softInputMode = (l.softInputMode
3206                             & (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION))
3207                             | forwardBit;
3208                     if (r.activity.mVisibleFromClient) {
3209                         ViewManager wm = a.getWindowManager();
3210                         View decor = r.window.getDecorView();
3211                         wm.updateViewLayout(decor, l);
3212                     }
3213                 }
3214                 r.activity.mVisibleFromServer = true;
3215                 mNumVisibleActivities++;
3216                 if (r.activity.mVisibleFromClient) {
3217                     r.activity.makeVisible();
3218                 }
3219             }
3220 
3221             if (!r.onlyLocalRequest) {
3222                 r.nextIdle = mNewActivities;
3223                 mNewActivities = r;
3224                 if (localLOGV) Slog.v(
3225                     TAG, "Scheduling idle handler for " + r);
3226                 Looper.myQueue().addIdleHandler(new Idler());
3227             }
3228             r.onlyLocalRequest = false;
3229 
3230             // Tell the activity manager we have resumed.
3231             if (reallyResume) {
3232                 try {
3233                     ActivityManagerNative.getDefault().activityResumed(token);
3234                 } catch (RemoteException ex) {
3235                 }
3236             }
3237 
3238         } else {
3239             // If an exception was thrown when trying to resume, then
3240             // just end this activity.
3241             try {
3242                 ActivityManagerNative.getDefault()
3243                     .finishActivity(token, Activity.RESULT_CANCELED, null, false);
3244             } catch (RemoteException ex) {
3245             }
3246         }
3247     }
3248 
3249     private int mThumbnailWidth = -1;
3250     private int mThumbnailHeight = -1;
3251     private Bitmap mAvailThumbnailBitmap = null;
3252     private Canvas mThumbnailCanvas = null;
3253 
createThumbnailBitmap(ActivityClientRecord r)3254     private Bitmap createThumbnailBitmap(ActivityClientRecord r) {
3255         Bitmap thumbnail = mAvailThumbnailBitmap;
3256         try {
3257             if (thumbnail == null) {
3258                 int w = mThumbnailWidth;
3259                 int h;
3260                 if (w < 0) {
3261                     Resources res = r.activity.getResources();
3262                     int wId = com.android.internal.R.dimen.thumbnail_width;
3263                     int hId = com.android.internal.R.dimen.thumbnail_height;
3264                     mThumbnailWidth = w = res.getDimensionPixelSize(wId);
3265                     mThumbnailHeight = h = res.getDimensionPixelSize(hId);
3266                 } else {
3267                     h = mThumbnailHeight;
3268                 }
3269 
3270                 // On platforms where we don't want thumbnails, set dims to (0,0)
3271                 if ((w > 0) && (h > 0)) {
3272                     thumbnail = Bitmap.createBitmap(r.activity.getResources().getDisplayMetrics(),
3273                             w, h, THUMBNAIL_FORMAT);
3274                     thumbnail.eraseColor(0);
3275                 }
3276             }
3277 
3278             if (thumbnail != null) {
3279                 Canvas cv = mThumbnailCanvas;
3280                 if (cv == null) {
3281                     mThumbnailCanvas = cv = new Canvas();
3282                 }
3283 
3284                 cv.setBitmap(thumbnail);
3285                 if (!r.activity.onCreateThumbnail(thumbnail, cv)) {
3286                     mAvailThumbnailBitmap = thumbnail;
3287                     thumbnail = null;
3288                 }
3289                 cv.setBitmap(null);
3290             }
3291 
3292         } catch (Exception e) {
3293             if (!mInstrumentation.onException(r.activity, e)) {
3294                 throw new RuntimeException(
3295                         "Unable to create thumbnail of "
3296                         + r.intent.getComponent().toShortString()
3297                         + ": " + e.toString(), e);
3298             }
3299             thumbnail = null;
3300         }
3301 
3302         return thumbnail;
3303     }
3304 
handlePauseActivity(IBinder token, boolean finished, boolean userLeaving, int configChanges, boolean dontReport)3305     private void handlePauseActivity(IBinder token, boolean finished,
3306             boolean userLeaving, int configChanges, boolean dontReport) {
3307         ActivityClientRecord r = mActivities.get(token);
3308         if (r != null) {
3309             //Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);
3310             if (userLeaving) {
3311                 performUserLeavingActivity(r);
3312             }
3313 
3314             r.activity.mConfigChangeFlags |= configChanges;
3315             performPauseActivity(token, finished, r.isPreHoneycomb());
3316 
3317             // Make sure any pending writes are now committed.
3318             if (r.isPreHoneycomb()) {
3319                 QueuedWork.waitToFinish();
3320             }
3321 
3322             // Tell the activity manager we have paused.
3323             if (!dontReport) {
3324                 try {
3325                     ActivityManagerNative.getDefault().activityPaused(token);
3326                 } catch (RemoteException ex) {
3327                 }
3328             }
3329             mSomeActivitiesChanged = true;
3330         }
3331     }
3332 
performUserLeavingActivity(ActivityClientRecord r)3333     final void performUserLeavingActivity(ActivityClientRecord r) {
3334         mInstrumentation.callActivityOnUserLeaving(r.activity);
3335     }
3336 
performPauseActivity(IBinder token, boolean finished, boolean saveState)3337     final Bundle performPauseActivity(IBinder token, boolean finished,
3338             boolean saveState) {
3339         ActivityClientRecord r = mActivities.get(token);
3340         return r != null ? performPauseActivity(r, finished, saveState) : null;
3341     }
3342 
performPauseActivity(ActivityClientRecord r, boolean finished, boolean saveState)3343     final Bundle performPauseActivity(ActivityClientRecord r, boolean finished,
3344             boolean saveState) {
3345         if (r.paused) {
3346             if (r.activity.mFinished) {
3347                 // If we are finishing, we won't call onResume() in certain cases.
3348                 // So here we likewise don't want to call onPause() if the activity
3349                 // isn't resumed.
3350                 return null;
3351             }
3352             RuntimeException e = new RuntimeException(
3353                     "Performing pause of activity that is not resumed: "
3354                     + r.intent.getComponent().toShortString());
3355             Slog.e(TAG, e.getMessage(), e);
3356         }
3357         if (finished) {
3358             r.activity.mFinished = true;
3359         }
3360         try {
3361             // Next have the activity save its current state and managed dialogs...
3362             if (!r.activity.mFinished && saveState) {
3363                 callCallActivityOnSaveInstanceState(r);
3364             }
3365             // Now we are idle.
3366             r.activity.mCalled = false;
3367             mInstrumentation.callActivityOnPause(r.activity);
3368             EventLog.writeEvent(LOG_AM_ON_PAUSE_CALLED, UserHandle.myUserId(),
3369                     r.activity.getComponentName().getClassName());
3370             if (!r.activity.mCalled) {
3371                 throw new SuperNotCalledException(
3372                     "Activity " + r.intent.getComponent().toShortString() +
3373                     " did not call through to super.onPause()");
3374             }
3375 
3376         } catch (SuperNotCalledException e) {
3377             throw e;
3378 
3379         } catch (Exception e) {
3380             if (!mInstrumentation.onException(r.activity, e)) {
3381                 throw new RuntimeException(
3382                         "Unable to pause activity "
3383                         + r.intent.getComponent().toShortString()
3384                         + ": " + e.toString(), e);
3385             }
3386         }
3387         r.paused = true;
3388 
3389         // Notify any outstanding on paused listeners
3390         ArrayList<OnActivityPausedListener> listeners;
3391         synchronized (mOnPauseListeners) {
3392             listeners = mOnPauseListeners.remove(r.activity);
3393         }
3394         int size = (listeners != null ? listeners.size() : 0);
3395         for (int i = 0; i < size; i++) {
3396             listeners.get(i).onPaused(r.activity);
3397         }
3398 
3399         return !r.activity.mFinished && saveState ? r.state : null;
3400     }
3401 
performStopActivity(IBinder token, boolean saveState)3402     final void performStopActivity(IBinder token, boolean saveState) {
3403         ActivityClientRecord r = mActivities.get(token);
3404         performStopActivityInner(r, null, false, saveState);
3405     }
3406 
3407     private static class StopInfo implements Runnable {
3408         ActivityClientRecord activity;
3409         Bundle state;
3410         PersistableBundle persistentState;
3411         CharSequence description;
3412 
run()3413         @Override public void run() {
3414             // Tell activity manager we have been stopped.
3415             try {
3416                 if (DEBUG_MEMORY_TRIM) Slog.v(TAG, "Reporting activity stopped: " + activity);
3417                 ActivityManagerNative.getDefault().activityStopped(
3418                     activity.token, state, persistentState, description);
3419             } catch (RemoteException ex) {
3420             }
3421         }
3422     }
3423 
3424     private static final class ProviderRefCount {
3425         public final IActivityManager.ContentProviderHolder holder;
3426         public final ProviderClientRecord client;
3427         public int stableCount;
3428         public int unstableCount;
3429 
3430         // When this is set, the stable and unstable ref counts are 0 and
3431         // we have a pending operation scheduled to remove the ref count
3432         // from the activity manager.  On the activity manager we are still
3433         // holding an unstable ref, though it is not reflected in the counts
3434         // here.
3435         public boolean removePending;
3436 
ProviderRefCount(IActivityManager.ContentProviderHolder inHolder, ProviderClientRecord inClient, int sCount, int uCount)3437         ProviderRefCount(IActivityManager.ContentProviderHolder inHolder,
3438                 ProviderClientRecord inClient, int sCount, int uCount) {
3439             holder = inHolder;
3440             client = inClient;
3441             stableCount = sCount;
3442             unstableCount = uCount;
3443         }
3444     }
3445 
3446     /**
3447      * Core implementation of stopping an activity.  Note this is a little
3448      * tricky because the server's meaning of stop is slightly different
3449      * than our client -- for the server, stop means to save state and give
3450      * it the result when it is done, but the window may still be visible.
3451      * For the client, we want to call onStop()/onStart() to indicate when
3452      * the activity's UI visibillity changes.
3453      */
performStopActivityInner(ActivityClientRecord r, StopInfo info, boolean keepShown, boolean saveState)3454     private void performStopActivityInner(ActivityClientRecord r,
3455             StopInfo info, boolean keepShown, boolean saveState) {
3456         if (localLOGV) Slog.v(TAG, "Performing stop of " + r);
3457         if (r != null) {
3458             if (!keepShown && r.stopped) {
3459                 if (r.activity.mFinished) {
3460                     // If we are finishing, we won't call onResume() in certain
3461                     // cases.  So here we likewise don't want to call onStop()
3462                     // if the activity isn't resumed.
3463                     return;
3464                 }
3465                 RuntimeException e = new RuntimeException(
3466                         "Performing stop of activity that is not resumed: "
3467                         + r.intent.getComponent().toShortString());
3468                 Slog.e(TAG, e.getMessage(), e);
3469             }
3470 
3471             if (info != null) {
3472                 try {
3473                     // First create a thumbnail for the activity...
3474                     // For now, don't create the thumbnail here; we are
3475                     // doing that by doing a screen snapshot.
3476                     info.description = r.activity.onCreateDescription();
3477                 } catch (Exception e) {
3478                     if (!mInstrumentation.onException(r.activity, e)) {
3479                         throw new RuntimeException(
3480                                 "Unable to save state of activity "
3481                                 + r.intent.getComponent().toShortString()
3482                                 + ": " + e.toString(), e);
3483                     }
3484                 }
3485             }
3486 
3487             // Next have the activity save its current state and managed dialogs...
3488             if (!r.activity.mFinished && saveState) {
3489                 if (r.state == null) {
3490                     callCallActivityOnSaveInstanceState(r);
3491                 }
3492             }
3493 
3494             if (!keepShown) {
3495                 try {
3496                     // Now we are idle.
3497                     r.activity.performStop();
3498                 } catch (Exception e) {
3499                     if (!mInstrumentation.onException(r.activity, e)) {
3500                         throw new RuntimeException(
3501                                 "Unable to stop activity "
3502                                 + r.intent.getComponent().toShortString()
3503                                 + ": " + e.toString(), e);
3504                     }
3505                 }
3506                 r.stopped = true;
3507             }
3508 
3509             r.paused = true;
3510         }
3511     }
3512 
updateVisibility(ActivityClientRecord r, boolean show)3513     private void updateVisibility(ActivityClientRecord r, boolean show) {
3514         View v = r.activity.mDecor;
3515         if (v != null) {
3516             if (show) {
3517                 if (!r.activity.mVisibleFromServer) {
3518                     r.activity.mVisibleFromServer = true;
3519                     mNumVisibleActivities++;
3520                     if (r.activity.mVisibleFromClient) {
3521                         r.activity.makeVisible();
3522                     }
3523                 }
3524                 if (r.newConfig != null) {
3525                     r.tmpConfig.setTo(r.newConfig);
3526                     if (r.overrideConfig != null) {
3527                         r.tmpConfig.updateFrom(r.overrideConfig);
3528                     }
3529                     if (DEBUG_CONFIGURATION) Slog.v(TAG, "Updating activity vis "
3530                             + r.activityInfo.name + " with new config " + r.tmpConfig);
3531                     performConfigurationChanged(r.activity, r.tmpConfig);
3532                     freeTextLayoutCachesIfNeeded(r.activity.mCurrentConfig.diff(r.tmpConfig));
3533                     r.newConfig = null;
3534                 }
3535             } else {
3536                 if (r.activity.mVisibleFromServer) {
3537                     r.activity.mVisibleFromServer = false;
3538                     mNumVisibleActivities--;
3539                     v.setVisibility(View.INVISIBLE);
3540                 }
3541             }
3542         }
3543     }
3544 
handleStopActivity(IBinder token, boolean show, int configChanges)3545     private void handleStopActivity(IBinder token, boolean show, int configChanges) {
3546         ActivityClientRecord r = mActivities.get(token);
3547         r.activity.mConfigChangeFlags |= configChanges;
3548 
3549         StopInfo info = new StopInfo();
3550         performStopActivityInner(r, info, show, true);
3551 
3552         if (localLOGV) Slog.v(
3553             TAG, "Finishing stop of " + r + ": show=" + show
3554             + " win=" + r.window);
3555 
3556         updateVisibility(r, show);
3557 
3558         // Make sure any pending writes are now committed.
3559         if (!r.isPreHoneycomb()) {
3560             QueuedWork.waitToFinish();
3561         }
3562 
3563         // Schedule the call to tell the activity manager we have
3564         // stopped.  We don't do this immediately, because we want to
3565         // have a chance for any other pending work (in particular memory
3566         // trim requests) to complete before you tell the activity
3567         // manager to proceed and allow us to go fully into the background.
3568         info.activity = r;
3569         info.state = r.state;
3570         info.persistentState = r.persistentState;
3571         mH.post(info);
3572         mSomeActivitiesChanged = true;
3573     }
3574 
performRestartActivity(IBinder token)3575     final void performRestartActivity(IBinder token) {
3576         ActivityClientRecord r = mActivities.get(token);
3577         if (r.stopped) {
3578             r.activity.performRestart();
3579             r.stopped = false;
3580         }
3581     }
3582 
handleWindowVisibility(IBinder token, boolean show)3583     private void handleWindowVisibility(IBinder token, boolean show) {
3584         ActivityClientRecord r = mActivities.get(token);
3585 
3586         if (r == null) {
3587             Log.w(TAG, "handleWindowVisibility: no activity for token " + token);
3588             return;
3589         }
3590 
3591         if (!show && !r.stopped) {
3592             performStopActivityInner(r, null, show, false);
3593         } else if (show && r.stopped) {
3594             // If we are getting ready to gc after going to the background, well
3595             // we are back active so skip it.
3596             unscheduleGcIdler();
3597 
3598             r.activity.performRestart();
3599             r.stopped = false;
3600         }
3601         if (r.activity.mDecor != null) {
3602             if (false) Slog.v(
3603                 TAG, "Handle window " + r + " visibility: " + show);
3604             updateVisibility(r, show);
3605         }
3606         mSomeActivitiesChanged = true;
3607     }
3608 
handleSleeping(IBinder token, boolean sleeping)3609     private void handleSleeping(IBinder token, boolean sleeping) {
3610         ActivityClientRecord r = mActivities.get(token);
3611 
3612         if (r == null) {
3613             Log.w(TAG, "handleSleeping: no activity for token " + token);
3614             return;
3615         }
3616 
3617         if (sleeping) {
3618             if (!r.stopped && !r.isPreHoneycomb()) {
3619                 try {
3620                     // Now we are idle.
3621                     r.activity.performStop();
3622                 } catch (Exception e) {
3623                     if (!mInstrumentation.onException(r.activity, e)) {
3624                         throw new RuntimeException(
3625                                 "Unable to stop activity "
3626                                 + r.intent.getComponent().toShortString()
3627                                 + ": " + e.toString(), e);
3628                     }
3629                 }
3630                 r.stopped = true;
3631             }
3632 
3633             // Make sure any pending writes are now committed.
3634             if (!r.isPreHoneycomb()) {
3635                 QueuedWork.waitToFinish();
3636             }
3637 
3638             // Tell activity manager we slept.
3639             try {
3640                 ActivityManagerNative.getDefault().activitySlept(r.token);
3641             } catch (RemoteException ex) {
3642             }
3643         } else {
3644             if (r.stopped && r.activity.mVisibleFromServer) {
3645                 r.activity.performRestart();
3646                 r.stopped = false;
3647             }
3648         }
3649     }
3650 
handleSetCoreSettings(Bundle coreSettings)3651     private void handleSetCoreSettings(Bundle coreSettings) {
3652         synchronized (mResourcesManager) {
3653             mCoreSettings = coreSettings;
3654         }
3655         onCoreSettingsChange();
3656     }
3657 
onCoreSettingsChange()3658     private void onCoreSettingsChange() {
3659         boolean debugViewAttributes =
3660                 mCoreSettings.getInt(Settings.Global.DEBUG_VIEW_ATTRIBUTES, 0) != 0;
3661         if (debugViewAttributes != View.mDebugViewAttributes) {
3662             View.mDebugViewAttributes = debugViewAttributes;
3663 
3664             // request all activities to relaunch for the changes to take place
3665             for (Map.Entry<IBinder, ActivityClientRecord> entry : mActivities.entrySet()) {
3666                 requestRelaunchActivity(entry.getKey(), null, null, 0, false, null, null, false);
3667             }
3668         }
3669     }
3670 
handleUpdatePackageCompatibilityInfo(UpdateCompatibilityData data)3671     private void handleUpdatePackageCompatibilityInfo(UpdateCompatibilityData data) {
3672         LoadedApk apk = peekPackageInfo(data.pkg, false);
3673         if (apk != null) {
3674             apk.setCompatibilityInfo(data.info);
3675         }
3676         apk = peekPackageInfo(data.pkg, true);
3677         if (apk != null) {
3678             apk.setCompatibilityInfo(data.info);
3679         }
3680         handleConfigurationChanged(mConfiguration, data.info);
3681         WindowManagerGlobal.getInstance().reportNewConfiguration(mConfiguration);
3682     }
3683 
deliverResults(ActivityClientRecord r, List<ResultInfo> results)3684     private void deliverResults(ActivityClientRecord r, List<ResultInfo> results) {
3685         final int N = results.size();
3686         for (int i=0; i<N; i++) {
3687             ResultInfo ri = results.get(i);
3688             try {
3689                 if (ri.mData != null) {
3690                     ri.mData.setExtrasClassLoader(r.activity.getClassLoader());
3691                     ri.mData.prepareToEnterProcess();
3692                 }
3693                 if (DEBUG_RESULTS) Slog.v(TAG,
3694                         "Delivering result to activity " + r + " : " + ri);
3695                 r.activity.dispatchActivityResult(ri.mResultWho,
3696                         ri.mRequestCode, ri.mResultCode, ri.mData);
3697             } catch (Exception e) {
3698                 if (!mInstrumentation.onException(r.activity, e)) {
3699                     throw new RuntimeException(
3700                             "Failure delivering result " + ri + " to activity "
3701                             + r.intent.getComponent().toShortString()
3702                             + ": " + e.toString(), e);
3703                 }
3704             }
3705         }
3706     }
3707 
handleSendResult(ResultData res)3708     private void handleSendResult(ResultData res) {
3709         ActivityClientRecord r = mActivities.get(res.token);
3710         if (DEBUG_RESULTS) Slog.v(TAG, "Handling send result to " + r);
3711         if (r != null) {
3712             final boolean resumed = !r.paused;
3713             if (!r.activity.mFinished && r.activity.mDecor != null
3714                     && r.hideForNow && resumed) {
3715                 // We had hidden the activity because it started another
3716                 // one...  we have gotten a result back and we are not
3717                 // paused, so make sure our window is visible.
3718                 updateVisibility(r, true);
3719             }
3720             if (resumed) {
3721                 try {
3722                     // Now we are idle.
3723                     r.activity.mCalled = false;
3724                     r.activity.mTemporaryPause = true;
3725                     mInstrumentation.callActivityOnPause(r.activity);
3726                     if (!r.activity.mCalled) {
3727                         throw new SuperNotCalledException(
3728                             "Activity " + r.intent.getComponent().toShortString()
3729                             + " did not call through to super.onPause()");
3730                     }
3731                 } catch (SuperNotCalledException e) {
3732                     throw e;
3733                 } catch (Exception e) {
3734                     if (!mInstrumentation.onException(r.activity, e)) {
3735                         throw new RuntimeException(
3736                                 "Unable to pause activity "
3737                                 + r.intent.getComponent().toShortString()
3738                                 + ": " + e.toString(), e);
3739                     }
3740                 }
3741             }
3742             deliverResults(r, res.results);
3743             if (resumed) {
3744                 r.activity.performResume();
3745                 r.activity.mTemporaryPause = false;
3746             }
3747         }
3748     }
3749 
performDestroyActivity(IBinder token, boolean finishing)3750     public final ActivityClientRecord performDestroyActivity(IBinder token, boolean finishing) {
3751         return performDestroyActivity(token, finishing, 0, false);
3752     }
3753 
performDestroyActivity(IBinder token, boolean finishing, int configChanges, boolean getNonConfigInstance)3754     private ActivityClientRecord performDestroyActivity(IBinder token, boolean finishing,
3755             int configChanges, boolean getNonConfigInstance) {
3756         ActivityClientRecord r = mActivities.get(token);
3757         Class<? extends Activity> activityClass = null;
3758         if (localLOGV) Slog.v(TAG, "Performing finish of " + r);
3759         if (r != null) {
3760             activityClass = r.activity.getClass();
3761             r.activity.mConfigChangeFlags |= configChanges;
3762             if (finishing) {
3763                 r.activity.mFinished = true;
3764             }
3765             if (!r.paused) {
3766                 try {
3767                     r.activity.mCalled = false;
3768                     mInstrumentation.callActivityOnPause(r.activity);
3769                     EventLog.writeEvent(LOG_AM_ON_PAUSE_CALLED, UserHandle.myUserId(),
3770                             r.activity.getComponentName().getClassName());
3771                     if (!r.activity.mCalled) {
3772                         throw new SuperNotCalledException(
3773                             "Activity " + safeToComponentShortString(r.intent)
3774                             + " did not call through to super.onPause()");
3775                     }
3776                 } catch (SuperNotCalledException e) {
3777                     throw e;
3778                 } catch (Exception e) {
3779                     if (!mInstrumentation.onException(r.activity, e)) {
3780                         throw new RuntimeException(
3781                                 "Unable to pause activity "
3782                                 + safeToComponentShortString(r.intent)
3783                                 + ": " + e.toString(), e);
3784                     }
3785                 }
3786                 r.paused = true;
3787             }
3788             if (!r.stopped) {
3789                 try {
3790                     r.activity.performStop();
3791                 } catch (SuperNotCalledException e) {
3792                     throw e;
3793                 } catch (Exception e) {
3794                     if (!mInstrumentation.onException(r.activity, e)) {
3795                         throw new RuntimeException(
3796                                 "Unable to stop activity "
3797                                 + safeToComponentShortString(r.intent)
3798                                 + ": " + e.toString(), e);
3799                     }
3800                 }
3801                 r.stopped = true;
3802             }
3803             if (getNonConfigInstance) {
3804                 try {
3805                     r.lastNonConfigurationInstances
3806                             = r.activity.retainNonConfigurationInstances();
3807                 } catch (Exception e) {
3808                     if (!mInstrumentation.onException(r.activity, e)) {
3809                         throw new RuntimeException(
3810                                 "Unable to retain activity "
3811                                 + r.intent.getComponent().toShortString()
3812                                 + ": " + e.toString(), e);
3813                     }
3814                 }
3815             }
3816             try {
3817                 r.activity.mCalled = false;
3818                 mInstrumentation.callActivityOnDestroy(r.activity);
3819                 if (!r.activity.mCalled) {
3820                     throw new SuperNotCalledException(
3821                         "Activity " + safeToComponentShortString(r.intent) +
3822                         " did not call through to super.onDestroy()");
3823                 }
3824                 if (r.window != null) {
3825                     r.window.closeAllPanels();
3826                 }
3827             } catch (SuperNotCalledException e) {
3828                 throw e;
3829             } catch (Exception e) {
3830                 if (!mInstrumentation.onException(r.activity, e)) {
3831                     throw new RuntimeException(
3832                             "Unable to destroy activity " + safeToComponentShortString(r.intent)
3833                             + ": " + e.toString(), e);
3834                 }
3835             }
3836         }
3837         mActivities.remove(token);
3838         StrictMode.decrementExpectedActivityCount(activityClass);
3839         return r;
3840     }
3841 
safeToComponentShortString(Intent intent)3842     private static String safeToComponentShortString(Intent intent) {
3843         ComponentName component = intent.getComponent();
3844         return component == null ? "[Unknown]" : component.toShortString();
3845     }
3846 
handleDestroyActivity(IBinder token, boolean finishing, int configChanges, boolean getNonConfigInstance)3847     private void handleDestroyActivity(IBinder token, boolean finishing,
3848             int configChanges, boolean getNonConfigInstance) {
3849         ActivityClientRecord r = performDestroyActivity(token, finishing,
3850                 configChanges, getNonConfigInstance);
3851         if (r != null) {
3852             cleanUpPendingRemoveWindows(r);
3853             WindowManager wm = r.activity.getWindowManager();
3854             View v = r.activity.mDecor;
3855             if (v != null) {
3856                 if (r.activity.mVisibleFromServer) {
3857                     mNumVisibleActivities--;
3858                 }
3859                 IBinder wtoken = v.getWindowToken();
3860                 if (r.activity.mWindowAdded) {
3861                     if (r.onlyLocalRequest) {
3862                         // Hold off on removing this until the new activity's
3863                         // window is being added.
3864                         r.mPendingRemoveWindow = v;
3865                         r.mPendingRemoveWindowManager = wm;
3866                     } else {
3867                         wm.removeViewImmediate(v);
3868                     }
3869                 }
3870                 if (wtoken != null && r.mPendingRemoveWindow == null) {
3871                     WindowManagerGlobal.getInstance().closeAll(wtoken,
3872                             r.activity.getClass().getName(), "Activity");
3873                 }
3874                 r.activity.mDecor = null;
3875             }
3876             if (r.mPendingRemoveWindow == null) {
3877                 // If we are delaying the removal of the activity window, then
3878                 // we can't clean up all windows here.  Note that we can't do
3879                 // so later either, which means any windows that aren't closed
3880                 // by the app will leak.  Well we try to warning them a lot
3881                 // about leaking windows, because that is a bug, so if they are
3882                 // using this recreate facility then they get to live with leaks.
3883                 WindowManagerGlobal.getInstance().closeAll(token,
3884                         r.activity.getClass().getName(), "Activity");
3885             }
3886 
3887             // Mocked out contexts won't be participating in the normal
3888             // process lifecycle, but if we're running with a proper
3889             // ApplicationContext we need to have it tear down things
3890             // cleanly.
3891             Context c = r.activity.getBaseContext();
3892             if (c instanceof ContextImpl) {
3893                 ((ContextImpl) c).scheduleFinalCleanup(
3894                         r.activity.getClass().getName(), "Activity");
3895             }
3896         }
3897         if (finishing) {
3898             try {
3899                 ActivityManagerNative.getDefault().activityDestroyed(token);
3900             } catch (RemoteException ex) {
3901                 // If the system process has died, it's game over for everyone.
3902             }
3903         }
3904         mSomeActivitiesChanged = true;
3905     }
3906 
requestRelaunchActivity(IBinder token, List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents, int configChanges, boolean notResumed, Configuration config, Configuration overrideConfig, boolean fromServer)3907     public final void requestRelaunchActivity(IBinder token,
3908             List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
3909             int configChanges, boolean notResumed, Configuration config,
3910             Configuration overrideConfig, boolean fromServer) {
3911         ActivityClientRecord target = null;
3912 
3913         synchronized (mResourcesManager) {
3914             for (int i=0; i<mRelaunchingActivities.size(); i++) {
3915                 ActivityClientRecord r = mRelaunchingActivities.get(i);
3916                 if (r.token == token) {
3917                     target = r;
3918                     if (pendingResults != null) {
3919                         if (r.pendingResults != null) {
3920                             r.pendingResults.addAll(pendingResults);
3921                         } else {
3922                             r.pendingResults = pendingResults;
3923                         }
3924                     }
3925                     if (pendingNewIntents != null) {
3926                         if (r.pendingIntents != null) {
3927                             r.pendingIntents.addAll(pendingNewIntents);
3928                         } else {
3929                             r.pendingIntents = pendingNewIntents;
3930                         }
3931                     }
3932                     break;
3933                 }
3934             }
3935 
3936             if (target == null) {
3937                 target = new ActivityClientRecord();
3938                 target.token = token;
3939                 target.pendingResults = pendingResults;
3940                 target.pendingIntents = pendingNewIntents;
3941                 if (!fromServer) {
3942                     ActivityClientRecord existing = mActivities.get(token);
3943                     if (existing != null) {
3944                         target.startsNotResumed = existing.paused;
3945                         target.overrideConfig = existing.overrideConfig;
3946                     }
3947                     target.onlyLocalRequest = true;
3948                 }
3949                 mRelaunchingActivities.add(target);
3950                 sendMessage(H.RELAUNCH_ACTIVITY, target);
3951             }
3952 
3953             if (fromServer) {
3954                 target.startsNotResumed = notResumed;
3955                 target.onlyLocalRequest = false;
3956             }
3957             if (config != null) {
3958                 target.createdConfig = config;
3959             }
3960             if (overrideConfig != null) {
3961                 target.overrideConfig = overrideConfig;
3962             }
3963             target.pendingConfigChanges |= configChanges;
3964         }
3965     }
3966 
handleRelaunchActivity(ActivityClientRecord tmp)3967     private void handleRelaunchActivity(ActivityClientRecord tmp) {
3968         // If we are getting ready to gc after going to the background, well
3969         // we are back active so skip it.
3970         unscheduleGcIdler();
3971         mSomeActivitiesChanged = true;
3972 
3973         Configuration changedConfig = null;
3974         int configChanges = 0;
3975 
3976         // First: make sure we have the most recent configuration and most
3977         // recent version of the activity, or skip it if some previous call
3978         // had taken a more recent version.
3979         synchronized (mResourcesManager) {
3980             int N = mRelaunchingActivities.size();
3981             IBinder token = tmp.token;
3982             tmp = null;
3983             for (int i=0; i<N; i++) {
3984                 ActivityClientRecord r = mRelaunchingActivities.get(i);
3985                 if (r.token == token) {
3986                     tmp = r;
3987                     configChanges |= tmp.pendingConfigChanges;
3988                     mRelaunchingActivities.remove(i);
3989                     i--;
3990                     N--;
3991                 }
3992             }
3993 
3994             if (tmp == null) {
3995                 if (DEBUG_CONFIGURATION) Slog.v(TAG, "Abort, activity not relaunching!");
3996                 return;
3997             }
3998 
3999             if (DEBUG_CONFIGURATION) Slog.v(TAG, "Relaunching activity "
4000                     + tmp.token + " with configChanges=0x"
4001                     + Integer.toHexString(configChanges));
4002 
4003             if (mPendingConfiguration != null) {
4004                 changedConfig = mPendingConfiguration;
4005                 mPendingConfiguration = null;
4006             }
4007         }
4008 
4009         if (tmp.createdConfig != null) {
4010             // If the activity manager is passing us its current config,
4011             // assume that is really what we want regardless of what we
4012             // may have pending.
4013             if (mConfiguration == null
4014                     || (tmp.createdConfig.isOtherSeqNewer(mConfiguration)
4015                             && mConfiguration.diff(tmp.createdConfig) != 0)) {
4016                 if (changedConfig == null
4017                         || tmp.createdConfig.isOtherSeqNewer(changedConfig)) {
4018                     changedConfig = tmp.createdConfig;
4019                 }
4020             }
4021         }
4022 
4023         if (DEBUG_CONFIGURATION) Slog.v(TAG, "Relaunching activity "
4024                 + tmp.token + ": changedConfig=" + changedConfig);
4025 
4026         // If there was a pending configuration change, execute it first.
4027         if (changedConfig != null) {
4028             mCurDefaultDisplayDpi = changedConfig.densityDpi;
4029             updateDefaultDensity();
4030             handleConfigurationChanged(changedConfig, null);
4031         }
4032 
4033         ActivityClientRecord r = mActivities.get(tmp.token);
4034         if (DEBUG_CONFIGURATION) Slog.v(TAG, "Handling relaunch of " + r);
4035         if (r == null) {
4036             return;
4037         }
4038 
4039         r.activity.mConfigChangeFlags |= configChanges;
4040         r.onlyLocalRequest = tmp.onlyLocalRequest;
4041         Intent currentIntent = r.activity.mIntent;
4042 
4043         r.activity.mChangingConfigurations = true;
4044 
4045         // Need to ensure state is saved.
4046         if (!r.paused) {
4047             performPauseActivity(r.token, false, r.isPreHoneycomb());
4048         }
4049         if (r.state == null && !r.stopped && !r.isPreHoneycomb()) {
4050             callCallActivityOnSaveInstanceState(r);
4051         }
4052 
4053         handleDestroyActivity(r.token, false, configChanges, true);
4054 
4055         r.activity = null;
4056         r.window = null;
4057         r.hideForNow = false;
4058         r.nextIdle = null;
4059         // Merge any pending results and pending intents; don't just replace them
4060         if (tmp.pendingResults != null) {
4061             if (r.pendingResults == null) {
4062                 r.pendingResults = tmp.pendingResults;
4063             } else {
4064                 r.pendingResults.addAll(tmp.pendingResults);
4065             }
4066         }
4067         if (tmp.pendingIntents != null) {
4068             if (r.pendingIntents == null) {
4069                 r.pendingIntents = tmp.pendingIntents;
4070             } else {
4071                 r.pendingIntents.addAll(tmp.pendingIntents);
4072             }
4073         }
4074         r.startsNotResumed = tmp.startsNotResumed;
4075         r.overrideConfig = tmp.overrideConfig;
4076 
4077         handleLaunchActivity(r, currentIntent);
4078     }
4079 
callCallActivityOnSaveInstanceState(ActivityClientRecord r)4080     private void callCallActivityOnSaveInstanceState(ActivityClientRecord r) {
4081         r.state = new Bundle();
4082         r.state.setAllowFds(false);
4083         if (r.isPersistable()) {
4084             r.persistentState = new PersistableBundle();
4085             mInstrumentation.callActivityOnSaveInstanceState(r.activity, r.state,
4086                     r.persistentState);
4087         } else {
4088             mInstrumentation.callActivityOnSaveInstanceState(r.activity, r.state);
4089         }
4090     }
4091 
collectComponentCallbacks( boolean allActivities, Configuration newConfig)4092     ArrayList<ComponentCallbacks2> collectComponentCallbacks(
4093             boolean allActivities, Configuration newConfig) {
4094         ArrayList<ComponentCallbacks2> callbacks
4095                 = new ArrayList<ComponentCallbacks2>();
4096 
4097         synchronized (mResourcesManager) {
4098             final int NAPP = mAllApplications.size();
4099             for (int i=0; i<NAPP; i++) {
4100                 callbacks.add(mAllApplications.get(i));
4101             }
4102             final int NACT = mActivities.size();
4103             for (int i=0; i<NACT; i++) {
4104                 ActivityClientRecord ar = mActivities.valueAt(i);
4105                 Activity a = ar.activity;
4106                 if (a != null) {
4107                     Configuration thisConfig = applyConfigCompatMainThread(
4108                             mCurDefaultDisplayDpi, newConfig,
4109                             ar.packageInfo.getCompatibilityInfo());
4110                     if (!ar.activity.mFinished && (allActivities || !ar.paused)) {
4111                         // If the activity is currently resumed, its configuration
4112                         // needs to change right now.
4113                         callbacks.add(a);
4114                     } else if (thisConfig != null) {
4115                         // Otherwise, we will tell it about the change
4116                         // the next time it is resumed or shown.  Note that
4117                         // the activity manager may, before then, decide the
4118                         // activity needs to be destroyed to handle its new
4119                         // configuration.
4120                         if (DEBUG_CONFIGURATION) {
4121                             Slog.v(TAG, "Setting activity "
4122                                     + ar.activityInfo.name + " newConfig=" + thisConfig);
4123                         }
4124                         ar.newConfig = thisConfig;
4125                     }
4126                 }
4127             }
4128             final int NSVC = mServices.size();
4129             for (int i=0; i<NSVC; i++) {
4130                 callbacks.add(mServices.valueAt(i));
4131             }
4132         }
4133         synchronized (mProviderMap) {
4134             final int NPRV = mLocalProviders.size();
4135             for (int i=0; i<NPRV; i++) {
4136                 callbacks.add(mLocalProviders.valueAt(i).mLocalProvider);
4137             }
4138         }
4139 
4140         return callbacks;
4141     }
4142 
performConfigurationChanged(ComponentCallbacks2 cb, Configuration config)4143     private static void performConfigurationChanged(ComponentCallbacks2 cb, Configuration config) {
4144         // Only for Activity objects, check that they actually call up to their
4145         // superclass implementation.  ComponentCallbacks2 is an interface, so
4146         // we check the runtime type and act accordingly.
4147         Activity activity = (cb instanceof Activity) ? (Activity) cb : null;
4148         if (activity != null) {
4149             activity.mCalled = false;
4150         }
4151 
4152         boolean shouldChangeConfig = false;
4153         if ((activity == null) || (activity.mCurrentConfig == null)) {
4154             shouldChangeConfig = true;
4155         } else {
4156 
4157             // If the new config is the same as the config this Activity
4158             // is already running with then don't bother calling
4159             // onConfigurationChanged
4160             int diff = activity.mCurrentConfig.diff(config);
4161             if (diff != 0) {
4162                 // If this activity doesn't handle any of the config changes
4163                 // then don't bother calling onConfigurationChanged as we're
4164                 // going to destroy it.
4165                 if ((~activity.mActivityInfo.getRealConfigChanged() & diff) == 0) {
4166                     shouldChangeConfig = true;
4167                 }
4168             }
4169         }
4170 
4171         if (DEBUG_CONFIGURATION) Slog.v(TAG, "Config callback " + cb
4172                 + ": shouldChangeConfig=" + shouldChangeConfig);
4173         if (shouldChangeConfig) {
4174             cb.onConfigurationChanged(config);
4175 
4176             if (activity != null) {
4177                 if (!activity.mCalled) {
4178                     throw new SuperNotCalledException(
4179                             "Activity " + activity.getLocalClassName() +
4180                         " did not call through to super.onConfigurationChanged()");
4181                 }
4182                 activity.mConfigChangeFlags = 0;
4183                 activity.mCurrentConfig = new Configuration(config);
4184             }
4185         }
4186     }
4187 
applyConfigurationToResources(Configuration config)4188     public final void applyConfigurationToResources(Configuration config) {
4189         synchronized (mResourcesManager) {
4190             mResourcesManager.applyConfigurationToResourcesLocked(config, null);
4191         }
4192     }
4193 
applyCompatConfiguration(int displayDensity)4194     final Configuration applyCompatConfiguration(int displayDensity) {
4195         Configuration config = mConfiguration;
4196         if (mCompatConfiguration == null) {
4197             mCompatConfiguration = new Configuration();
4198         }
4199         mCompatConfiguration.setTo(mConfiguration);
4200         if (mResourcesManager.applyCompatConfiguration(displayDensity, mCompatConfiguration)) {
4201             config = mCompatConfiguration;
4202         }
4203         return config;
4204     }
4205 
handleConfigurationChanged(Configuration config, CompatibilityInfo compat)4206     final void handleConfigurationChanged(Configuration config, CompatibilityInfo compat) {
4207 
4208         int configDiff = 0;
4209 
4210         synchronized (mResourcesManager) {
4211             if (mPendingConfiguration != null) {
4212                 if (!mPendingConfiguration.isOtherSeqNewer(config)) {
4213                     config = mPendingConfiguration;
4214                     mCurDefaultDisplayDpi = config.densityDpi;
4215                     updateDefaultDensity();
4216                 }
4217                 mPendingConfiguration = null;
4218             }
4219 
4220             if (config == null) {
4221                 return;
4222             }
4223 
4224             if (DEBUG_CONFIGURATION) Slog.v(TAG, "Handle configuration changed: "
4225                     + config);
4226 
4227             mResourcesManager.applyConfigurationToResourcesLocked(config, compat);
4228 
4229             if (mConfiguration == null) {
4230                 mConfiguration = new Configuration();
4231             }
4232             if (!mConfiguration.isOtherSeqNewer(config) && compat == null) {
4233                 return;
4234             }
4235 
4236             configDiff = mConfiguration.updateFrom(config);
4237             config = applyCompatConfiguration(mCurDefaultDisplayDpi);
4238         }
4239 
4240         ArrayList<ComponentCallbacks2> callbacks = collectComponentCallbacks(false, config);
4241 
4242         freeTextLayoutCachesIfNeeded(configDiff);
4243 
4244         if (callbacks != null) {
4245             final int N = callbacks.size();
4246             for (int i=0; i<N; i++) {
4247                 performConfigurationChanged(callbacks.get(i), config);
4248             }
4249         }
4250     }
4251 
freeTextLayoutCachesIfNeeded(int configDiff)4252     static void freeTextLayoutCachesIfNeeded(int configDiff) {
4253         if (configDiff != 0) {
4254             // Ask text layout engine to free its caches if there is a locale change
4255             boolean hasLocaleConfigChange = ((configDiff & ActivityInfo.CONFIG_LOCALE) != 0);
4256             if (hasLocaleConfigChange) {
4257                 Canvas.freeTextLayoutCaches();
4258                 if (DEBUG_CONFIGURATION) Slog.v(TAG, "Cleared TextLayout Caches");
4259             }
4260         }
4261     }
4262 
handleActivityConfigurationChanged(ActivityConfigChangeData data)4263     final void handleActivityConfigurationChanged(ActivityConfigChangeData data) {
4264         ActivityClientRecord r = mActivities.get(data.activityToken);
4265         if (r == null || r.activity == null) {
4266             return;
4267         }
4268 
4269         if (DEBUG_CONFIGURATION) Slog.v(TAG, "Handle activity config changed: "
4270                 + r.activityInfo.name);
4271 
4272         r.tmpConfig.setTo(mCompatConfiguration);
4273         if (data.overrideConfig != null) {
4274             r.overrideConfig = data.overrideConfig;
4275             r.tmpConfig.updateFrom(data.overrideConfig);
4276         }
4277         performConfigurationChanged(r.activity, r.tmpConfig);
4278 
4279         freeTextLayoutCachesIfNeeded(r.activity.mCurrentConfig.diff(mCompatConfiguration));
4280 
4281         mSomeActivitiesChanged = true;
4282     }
4283 
handleProfilerControl(boolean start, ProfilerInfo profilerInfo, int profileType)4284     final void handleProfilerControl(boolean start, ProfilerInfo profilerInfo, int profileType) {
4285         if (start) {
4286             try {
4287                 switch (profileType) {
4288                     default:
4289                         mProfiler.setProfiler(profilerInfo);
4290                         mProfiler.startProfiling();
4291                         break;
4292                 }
4293             } catch (RuntimeException e) {
4294                 Slog.w(TAG, "Profiling failed on path " + profilerInfo.profileFile
4295                         + " -- can the process access this path?");
4296             } finally {
4297                 try {
4298                     profilerInfo.profileFd.close();
4299                 } catch (IOException e) {
4300                     Slog.w(TAG, "Failure closing profile fd", e);
4301                 }
4302             }
4303         } else {
4304             switch (profileType) {
4305                 default:
4306                     mProfiler.stopProfiling();
4307                     break;
4308             }
4309         }
4310     }
4311 
handleDumpHeap(boolean managed, DumpHeapData dhd)4312     static final void handleDumpHeap(boolean managed, DumpHeapData dhd) {
4313         if (managed) {
4314             try {
4315                 Debug.dumpHprofData(dhd.path, dhd.fd.getFileDescriptor());
4316             } catch (IOException e) {
4317                 Slog.w(TAG, "Managed heap dump failed on path " + dhd.path
4318                         + " -- can the process access this path?");
4319             } finally {
4320                 try {
4321                     dhd.fd.close();
4322                 } catch (IOException e) {
4323                     Slog.w(TAG, "Failure closing profile fd", e);
4324                 }
4325             }
4326         } else {
4327             Debug.dumpNativeHeap(dhd.fd.getFileDescriptor());
4328         }
4329         try {
4330             ActivityManagerNative.getDefault().dumpHeapFinished(dhd.path);
4331         } catch (RemoteException e) {
4332         }
4333     }
4334 
handleDispatchPackageBroadcast(int cmd, String[] packages)4335     final void handleDispatchPackageBroadcast(int cmd, String[] packages) {
4336         boolean hasPkgInfo = false;
4337         if (packages != null) {
4338             synchronized (mResourcesManager) {
4339                 for (int i=packages.length-1; i>=0; i--) {
4340                     //Slog.i(TAG, "Cleaning old package: " + packages[i]);
4341                     if (!hasPkgInfo) {
4342                         WeakReference<LoadedApk> ref;
4343                         ref = mPackages.get(packages[i]);
4344                         if (ref != null && ref.get() != null) {
4345                             hasPkgInfo = true;
4346                         } else {
4347                             ref = mResourcePackages.get(packages[i]);
4348                             if (ref != null && ref.get() != null) {
4349                                 hasPkgInfo = true;
4350                             }
4351                         }
4352                     }
4353                     mPackages.remove(packages[i]);
4354                     mResourcePackages.remove(packages[i]);
4355                 }
4356             }
4357         }
4358         ApplicationPackageManager.handlePackageBroadcast(cmd, packages,
4359                 hasPkgInfo);
4360     }
4361 
handleLowMemory()4362     final void handleLowMemory() {
4363         ArrayList<ComponentCallbacks2> callbacks = collectComponentCallbacks(true, null);
4364 
4365         final int N = callbacks.size();
4366         for (int i=0; i<N; i++) {
4367             callbacks.get(i).onLowMemory();
4368         }
4369 
4370         // Ask SQLite to free up as much memory as it can, mostly from its page caches.
4371         if (Process.myUid() != Process.SYSTEM_UID) {
4372             int sqliteReleased = SQLiteDatabase.releaseMemory();
4373             EventLog.writeEvent(SQLITE_MEM_RELEASED_EVENT_LOG_TAG, sqliteReleased);
4374         }
4375 
4376         // Ask graphics to free up as much as possible (font/image caches)
4377         Canvas.freeCaches();
4378 
4379         // Ask text layout engine to free also as much as possible
4380         Canvas.freeTextLayoutCaches();
4381 
4382         BinderInternal.forceGc("mem");
4383     }
4384 
handleTrimMemory(int level)4385     final void handleTrimMemory(int level) {
4386         if (DEBUG_MEMORY_TRIM) Slog.v(TAG, "Trimming memory to level: " + level);
4387 
4388         ArrayList<ComponentCallbacks2> callbacks = collectComponentCallbacks(true, null);
4389 
4390         final int N = callbacks.size();
4391         for (int i = 0; i < N; i++) {
4392             callbacks.get(i).onTrimMemory(level);
4393         }
4394 
4395         WindowManagerGlobal.getInstance().trimMemory(level);
4396     }
4397 
setupGraphicsSupport(LoadedApk info, File cacheDir)4398     private void setupGraphicsSupport(LoadedApk info, File cacheDir) {
4399         if (Process.isIsolated()) {
4400             // Isolated processes aren't going to do UI.
4401             return;
4402         }
4403         try {
4404             int uid = Process.myUid();
4405             String[] packages = getPackageManager().getPackagesForUid(uid);
4406 
4407             // If there are several packages in this application we won't
4408             // initialize the graphics disk caches
4409             if (packages != null && packages.length == 1) {
4410                 HardwareRenderer.setupDiskCache(cacheDir);
4411                 RenderScriptCacheDir.setupDiskCache(cacheDir);
4412             }
4413         } catch (RemoteException e) {
4414             // Ignore
4415         }
4416     }
4417 
updateDefaultDensity()4418     private void updateDefaultDensity() {
4419         if (mCurDefaultDisplayDpi != Configuration.DENSITY_DPI_UNDEFINED
4420                 && mCurDefaultDisplayDpi != DisplayMetrics.DENSITY_DEVICE
4421                 && !mDensityCompatMode) {
4422             Slog.i(TAG, "Switching default density from "
4423                     + DisplayMetrics.DENSITY_DEVICE + " to "
4424                     + mCurDefaultDisplayDpi);
4425             DisplayMetrics.DENSITY_DEVICE = mCurDefaultDisplayDpi;
4426             Bitmap.setDefaultDensity(DisplayMetrics.DENSITY_DEFAULT);
4427         }
4428     }
4429 
handleBindApplication(AppBindData data)4430     private void handleBindApplication(AppBindData data) {
4431         mBoundApplication = data;
4432         mConfiguration = new Configuration(data.config);
4433         mCompatConfiguration = new Configuration(data.config);
4434 
4435         mProfiler = new Profiler();
4436         if (data.initProfilerInfo != null) {
4437             mProfiler.profileFile = data.initProfilerInfo.profileFile;
4438             mProfiler.profileFd = data.initProfilerInfo.profileFd;
4439             mProfiler.samplingInterval = data.initProfilerInfo.samplingInterval;
4440             mProfiler.autoStopProfiler = data.initProfilerInfo.autoStopProfiler;
4441         }
4442 
4443         // send up app name; do this *before* waiting for debugger
4444         Process.setArgV0(data.processName);
4445         android.ddm.DdmHandleAppName.setAppName(data.processName,
4446                                                 UserHandle.myUserId());
4447 
4448         if (data.persistent) {
4449             // Persistent processes on low-memory devices do not get to
4450             // use hardware accelerated drawing, since this can add too much
4451             // overhead to the process.
4452             if (!ActivityManager.isHighEndGfx()) {
4453                 HardwareRenderer.disable(false);
4454             }
4455         }
4456 
4457         if (mProfiler.profileFd != null) {
4458             mProfiler.startProfiling();
4459         }
4460 
4461         // If the app is Honeycomb MR1 or earlier, switch its AsyncTask
4462         // implementation to use the pool executor.  Normally, we use the
4463         // serialized executor as the default. This has to happen in the
4464         // main thread so the main looper is set right.
4465         if (data.appInfo.targetSdkVersion <= android.os.Build.VERSION_CODES.HONEYCOMB_MR1) {
4466             AsyncTask.setDefaultExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
4467         }
4468 
4469         Message.updateCheckRecycle(data.appInfo.targetSdkVersion);
4470 
4471         /*
4472          * Before spawning a new process, reset the time zone to be the system time zone.
4473          * This needs to be done because the system time zone could have changed after the
4474          * the spawning of this process. Without doing this this process would have the incorrect
4475          * system time zone.
4476          */
4477         TimeZone.setDefault(null);
4478 
4479         /*
4480          * Initialize the default locale in this process for the reasons we set the time zone.
4481          */
4482         Locale.setDefault(data.config.locale);
4483 
4484         /*
4485          * Update the system configuration since its preloaded and might not
4486          * reflect configuration changes. The configuration object passed
4487          * in AppBindData can be safely assumed to be up to date
4488          */
4489         mResourcesManager.applyConfigurationToResourcesLocked(data.config, data.compatInfo);
4490         mCurDefaultDisplayDpi = data.config.densityDpi;
4491         applyCompatConfiguration(mCurDefaultDisplayDpi);
4492 
4493         data.info = getPackageInfoNoCheck(data.appInfo, data.compatInfo);
4494 
4495         /**
4496          * Switch this process to density compatibility mode if needed.
4497          */
4498         if ((data.appInfo.flags&ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES)
4499                 == 0) {
4500             mDensityCompatMode = true;
4501             Bitmap.setDefaultDensity(DisplayMetrics.DENSITY_DEFAULT);
4502         }
4503         updateDefaultDensity();
4504 
4505         final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
4506         if (!Process.isIsolated()) {
4507             final File cacheDir = appContext.getCacheDir();
4508 
4509             if (cacheDir != null) {
4510                 // Provide a usable directory for temporary files
4511                 System.setProperty("java.io.tmpdir", cacheDir.getAbsolutePath());
4512             } else {
4513                 Log.v(TAG, "Unable to initialize \"java.io.tmpdir\" property due to missing cache directory");
4514             }
4515 
4516             // Use codeCacheDir to store generated/compiled graphics code
4517             final File codeCacheDir = appContext.getCodeCacheDir();
4518             if (codeCacheDir != null) {
4519                 setupGraphicsSupport(data.info, codeCacheDir);
4520             } else {
4521                 Log.e(TAG, "Unable to setupGraphicsSupport due to missing code-cache directory");
4522             }
4523         }
4524 
4525 
4526         final boolean is24Hr = "24".equals(mCoreSettings.getString(Settings.System.TIME_12_24));
4527         DateFormat.set24HourTimePref(is24Hr);
4528 
4529         View.mDebugViewAttributes =
4530                 mCoreSettings.getInt(Settings.Global.DEBUG_VIEW_ATTRIBUTES, 0) != 0;
4531 
4532         /**
4533          * For system applications on userdebug/eng builds, log stack
4534          * traces of disk and network access to dropbox for analysis.
4535          */
4536         if ((data.appInfo.flags &
4537              (ApplicationInfo.FLAG_SYSTEM |
4538               ApplicationInfo.FLAG_UPDATED_SYSTEM_APP)) != 0) {
4539             StrictMode.conditionallyEnableDebugLogging();
4540         }
4541 
4542         /**
4543          * For apps targetting SDK Honeycomb or later, we don't allow
4544          * network usage on the main event loop / UI thread.
4545          *
4546          * Note to those grepping:  this is what ultimately throws
4547          * NetworkOnMainThreadException ...
4548          */
4549         if (data.appInfo.targetSdkVersion > 9) {
4550             StrictMode.enableDeathOnNetwork();
4551         }
4552 
4553         NetworkSecurityPolicy.getInstance().setCleartextTrafficPermitted(
4554                 (data.appInfo.flags & ApplicationInfo.FLAG_USES_CLEARTEXT_TRAFFIC) != 0);
4555 
4556         if (data.debugMode != IApplicationThread.DEBUG_OFF) {
4557             // XXX should have option to change the port.
4558             Debug.changeDebugPort(8100);
4559             if (data.debugMode == IApplicationThread.DEBUG_WAIT) {
4560                 Slog.w(TAG, "Application " + data.info.getPackageName()
4561                       + " is waiting for the debugger on port 8100...");
4562 
4563                 IActivityManager mgr = ActivityManagerNative.getDefault();
4564                 try {
4565                     mgr.showWaitingForDebugger(mAppThread, true);
4566                 } catch (RemoteException ex) {
4567                 }
4568 
4569                 Debug.waitForDebugger();
4570 
4571                 try {
4572                     mgr.showWaitingForDebugger(mAppThread, false);
4573                 } catch (RemoteException ex) {
4574                 }
4575 
4576             } else {
4577                 Slog.w(TAG, "Application " + data.info.getPackageName()
4578                       + " can be debugged on port 8100...");
4579             }
4580         }
4581 
4582         // Enable OpenGL tracing if required
4583         if (data.enableOpenGlTrace) {
4584             GLUtils.setTracingLevel(1);
4585         }
4586 
4587         // Allow application-generated systrace messages if we're debuggable.
4588         boolean appTracingAllowed = (data.appInfo.flags&ApplicationInfo.FLAG_DEBUGGABLE) != 0;
4589         Trace.setAppTracingAllowed(appTracingAllowed);
4590 
4591         /**
4592          * Initialize the default http proxy in this process for the reasons we set the time zone.
4593          */
4594         IBinder b = ServiceManager.getService(Context.CONNECTIVITY_SERVICE);
4595         if (b != null) {
4596             // In pre-boot mode (doing initial launch to collect password), not
4597             // all system is up.  This includes the connectivity service, so don't
4598             // crash if we can't get it.
4599             IConnectivityManager service = IConnectivityManager.Stub.asInterface(b);
4600             try {
4601                 final ProxyInfo proxyInfo = service.getProxyForNetwork(null);
4602                 Proxy.setHttpProxySystemProperty(proxyInfo);
4603             } catch (RemoteException e) {}
4604         }
4605 
4606         if (data.instrumentationName != null) {
4607             InstrumentationInfo ii = null;
4608             try {
4609                 ii = appContext.getPackageManager().
4610                     getInstrumentationInfo(data.instrumentationName, 0);
4611             } catch (PackageManager.NameNotFoundException e) {
4612             }
4613             if (ii == null) {
4614                 throw new RuntimeException(
4615                     "Unable to find instrumentation info for: "
4616                     + data.instrumentationName);
4617             }
4618 
4619             mInstrumentationPackageName = ii.packageName;
4620             mInstrumentationAppDir = ii.sourceDir;
4621             mInstrumentationSplitAppDirs = ii.splitSourceDirs;
4622             mInstrumentationLibDir = ii.nativeLibraryDir;
4623             mInstrumentedAppDir = data.info.getAppDir();
4624             mInstrumentedSplitAppDirs = data.info.getSplitAppDirs();
4625             mInstrumentedLibDir = data.info.getLibDir();
4626 
4627             ApplicationInfo instrApp = new ApplicationInfo();
4628             instrApp.packageName = ii.packageName;
4629             instrApp.sourceDir = ii.sourceDir;
4630             instrApp.publicSourceDir = ii.publicSourceDir;
4631             instrApp.splitSourceDirs = ii.splitSourceDirs;
4632             instrApp.splitPublicSourceDirs = ii.splitPublicSourceDirs;
4633             instrApp.dataDir = ii.dataDir;
4634             instrApp.nativeLibraryDir = ii.nativeLibraryDir;
4635             LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,
4636                     appContext.getClassLoader(), false, true, false);
4637             ContextImpl instrContext = ContextImpl.createAppContext(this, pi);
4638 
4639             try {
4640                 java.lang.ClassLoader cl = instrContext.getClassLoader();
4641                 mInstrumentation = (Instrumentation)
4642                     cl.loadClass(data.instrumentationName.getClassName()).newInstance();
4643             } catch (Exception e) {
4644                 throw new RuntimeException(
4645                     "Unable to instantiate instrumentation "
4646                     + data.instrumentationName + ": " + e.toString(), e);
4647             }
4648 
4649             mInstrumentation.init(this, instrContext, appContext,
4650                    new ComponentName(ii.packageName, ii.name), data.instrumentationWatcher,
4651                    data.instrumentationUiAutomationConnection);
4652 
4653             if (mProfiler.profileFile != null && !ii.handleProfiling
4654                     && mProfiler.profileFd == null) {
4655                 mProfiler.handlingProfiling = true;
4656                 File file = new File(mProfiler.profileFile);
4657                 file.getParentFile().mkdirs();
4658                 Debug.startMethodTracing(file.toString(), 8 * 1024 * 1024);
4659             }
4660 
4661         } else {
4662             mInstrumentation = new Instrumentation();
4663         }
4664 
4665         if ((data.appInfo.flags&ApplicationInfo.FLAG_LARGE_HEAP) != 0) {
4666             dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();
4667         } else {
4668             // Small heap, clamp to the current growth limit and let the heap release
4669             // pages after the growth limit to the non growth limit capacity. b/18387825
4670             dalvik.system.VMRuntime.getRuntime().clampGrowthLimit();
4671         }
4672 
4673         // Allow disk access during application and provider setup. This could
4674         // block processing ordered broadcasts, but later processing would
4675         // probably end up doing the same disk access.
4676         final StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskWrites();
4677         try {
4678             // If the app is being launched for full backup or restore, bring it up in
4679             // a restricted environment with the base application class.
4680             Application app = data.info.makeApplication(data.restrictedBackupMode, null);
4681             mInitialApplication = app;
4682 
4683             // don't bring up providers in restricted mode; they may depend on the
4684             // app's custom Application class
4685             if (!data.restrictedBackupMode) {
4686                 List<ProviderInfo> providers = data.providers;
4687                 if (providers != null) {
4688                     installContentProviders(app, providers);
4689                     // For process that contains content providers, we want to
4690                     // ensure that the JIT is enabled "at some point".
4691                     mH.sendEmptyMessageDelayed(H.ENABLE_JIT, 10*1000);
4692                 }
4693             }
4694 
4695             // Do this after providers, since instrumentation tests generally start their
4696             // test thread at this point, and we don't want that racing.
4697             try {
4698                 mInstrumentation.onCreate(data.instrumentationArgs);
4699             }
4700             catch (Exception e) {
4701                 throw new RuntimeException(
4702                     "Exception thrown in onCreate() of "
4703                     + data.instrumentationName + ": " + e.toString(), e);
4704             }
4705 
4706             try {
4707                 mInstrumentation.callApplicationOnCreate(app);
4708             } catch (Exception e) {
4709                 if (!mInstrumentation.onException(app, e)) {
4710                     throw new RuntimeException(
4711                         "Unable to create application " + app.getClass().getName()
4712                         + ": " + e.toString(), e);
4713                 }
4714             }
4715         } finally {
4716             StrictMode.setThreadPolicy(savedPolicy);
4717         }
4718     }
4719 
finishInstrumentation(int resultCode, Bundle results)4720     /*package*/ final void finishInstrumentation(int resultCode, Bundle results) {
4721         IActivityManager am = ActivityManagerNative.getDefault();
4722         if (mProfiler.profileFile != null && mProfiler.handlingProfiling
4723                 && mProfiler.profileFd == null) {
4724             Debug.stopMethodTracing();
4725         }
4726         //Slog.i(TAG, "am: " + ActivityManagerNative.getDefault()
4727         //      + ", app thr: " + mAppThread);
4728         try {
4729             am.finishInstrumentation(mAppThread, resultCode, results);
4730         } catch (RemoteException ex) {
4731         }
4732     }
4733 
installContentProviders( Context context, List<ProviderInfo> providers)4734     private void installContentProviders(
4735             Context context, List<ProviderInfo> providers) {
4736         final ArrayList<IActivityManager.ContentProviderHolder> results =
4737             new ArrayList<IActivityManager.ContentProviderHolder>();
4738 
4739         for (ProviderInfo cpi : providers) {
4740             if (DEBUG_PROVIDER) {
4741                 StringBuilder buf = new StringBuilder(128);
4742                 buf.append("Pub ");
4743                 buf.append(cpi.authority);
4744                 buf.append(": ");
4745                 buf.append(cpi.name);
4746                 Log.i(TAG, buf.toString());
4747             }
4748             IActivityManager.ContentProviderHolder cph = installProvider(context, null, cpi,
4749                     false /*noisy*/, true /*noReleaseNeeded*/, true /*stable*/);
4750             if (cph != null) {
4751                 cph.noReleaseNeeded = true;
4752                 results.add(cph);
4753             }
4754         }
4755 
4756         try {
4757             ActivityManagerNative.getDefault().publishContentProviders(
4758                 getApplicationThread(), results);
4759         } catch (RemoteException ex) {
4760         }
4761     }
4762 
acquireProvider( Context c, String auth, int userId, boolean stable)4763     public final IContentProvider acquireProvider(
4764             Context c, String auth, int userId, boolean stable) {
4765         final IContentProvider provider = acquireExistingProvider(c, auth, userId, stable);
4766         if (provider != null) {
4767             return provider;
4768         }
4769 
4770         // There is a possible race here.  Another thread may try to acquire
4771         // the same provider at the same time.  When this happens, we want to ensure
4772         // that the first one wins.
4773         // Note that we cannot hold the lock while acquiring and installing the
4774         // provider since it might take a long time to run and it could also potentially
4775         // be re-entrant in the case where the provider is in the same process.
4776         IActivityManager.ContentProviderHolder holder = null;
4777         try {
4778             holder = ActivityManagerNative.getDefault().getContentProvider(
4779                     getApplicationThread(), auth, userId, stable);
4780         } catch (RemoteException ex) {
4781         }
4782         if (holder == null) {
4783             Slog.e(TAG, "Failed to find provider info for " + auth);
4784             return null;
4785         }
4786 
4787         // Install provider will increment the reference count for us, and break
4788         // any ties in the race.
4789         holder = installProvider(c, holder, holder.info,
4790                 true /*noisy*/, holder.noReleaseNeeded, stable);
4791         return holder.provider;
4792     }
4793 
incProviderRefLocked(ProviderRefCount prc, boolean stable)4794     private final void incProviderRefLocked(ProviderRefCount prc, boolean stable) {
4795         if (stable) {
4796             prc.stableCount += 1;
4797             if (prc.stableCount == 1) {
4798                 // We are acquiring a new stable reference on the provider.
4799                 int unstableDelta;
4800                 if (prc.removePending) {
4801                     // We have a pending remove operation, which is holding the
4802                     // last unstable reference.  At this point we are converting
4803                     // that unstable reference to our new stable reference.
4804                     unstableDelta = -1;
4805                     // Cancel the removal of the provider.
4806                     if (DEBUG_PROVIDER) {
4807                         Slog.v(TAG, "incProviderRef: stable "
4808                                 + "snatched provider from the jaws of death");
4809                     }
4810                     prc.removePending = false;
4811                     // There is a race! It fails to remove the message, which
4812                     // will be handled in completeRemoveProvider().
4813                     mH.removeMessages(H.REMOVE_PROVIDER, prc);
4814                 } else {
4815                     unstableDelta = 0;
4816                 }
4817                 try {
4818                     if (DEBUG_PROVIDER) {
4819                         Slog.v(TAG, "incProviderRef Now stable - "
4820                                 + prc.holder.info.name + ": unstableDelta="
4821                                 + unstableDelta);
4822                     }
4823                     ActivityManagerNative.getDefault().refContentProvider(
4824                             prc.holder.connection, 1, unstableDelta);
4825                 } catch (RemoteException e) {
4826                     //do nothing content provider object is dead any way
4827                 }
4828             }
4829         } else {
4830             prc.unstableCount += 1;
4831             if (prc.unstableCount == 1) {
4832                 // We are acquiring a new unstable reference on the provider.
4833                 if (prc.removePending) {
4834                     // Oh look, we actually have a remove pending for the
4835                     // provider, which is still holding the last unstable
4836                     // reference.  We just need to cancel that to take new
4837                     // ownership of the reference.
4838                     if (DEBUG_PROVIDER) {
4839                         Slog.v(TAG, "incProviderRef: unstable "
4840                                 + "snatched provider from the jaws of death");
4841                     }
4842                     prc.removePending = false;
4843                     mH.removeMessages(H.REMOVE_PROVIDER, prc);
4844                 } else {
4845                     // First unstable ref, increment our count in the
4846                     // activity manager.
4847                     try {
4848                         if (DEBUG_PROVIDER) {
4849                             Slog.v(TAG, "incProviderRef: Now unstable - "
4850                                     + prc.holder.info.name);
4851                         }
4852                         ActivityManagerNative.getDefault().refContentProvider(
4853                                 prc.holder.connection, 0, 1);
4854                     } catch (RemoteException e) {
4855                         //do nothing content provider object is dead any way
4856                     }
4857                 }
4858             }
4859         }
4860     }
4861 
acquireExistingProvider( Context c, String auth, int userId, boolean stable)4862     public final IContentProvider acquireExistingProvider(
4863             Context c, String auth, int userId, boolean stable) {
4864         synchronized (mProviderMap) {
4865             final ProviderKey key = new ProviderKey(auth, userId);
4866             final ProviderClientRecord pr = mProviderMap.get(key);
4867             if (pr == null) {
4868                 return null;
4869             }
4870 
4871             IContentProvider provider = pr.mProvider;
4872             IBinder jBinder = provider.asBinder();
4873             if (!jBinder.isBinderAlive()) {
4874                 // The hosting process of the provider has died; we can't
4875                 // use this one.
4876                 Log.i(TAG, "Acquiring provider " + auth + " for user " + userId
4877                         + ": existing object's process dead");
4878                 handleUnstableProviderDiedLocked(jBinder, true);
4879                 return null;
4880             }
4881 
4882             // Only increment the ref count if we have one.  If we don't then the
4883             // provider is not reference counted and never needs to be released.
4884             ProviderRefCount prc = mProviderRefCountMap.get(jBinder);
4885             if (prc != null) {
4886                 incProviderRefLocked(prc, stable);
4887             }
4888             return provider;
4889         }
4890     }
4891 
releaseProvider(IContentProvider provider, boolean stable)4892     public final boolean releaseProvider(IContentProvider provider, boolean stable) {
4893         if (provider == null) {
4894             return false;
4895         }
4896 
4897         IBinder jBinder = provider.asBinder();
4898         synchronized (mProviderMap) {
4899             ProviderRefCount prc = mProviderRefCountMap.get(jBinder);
4900             if (prc == null) {
4901                 // The provider has no ref count, no release is needed.
4902                 return false;
4903             }
4904 
4905             boolean lastRef = false;
4906             if (stable) {
4907                 if (prc.stableCount == 0) {
4908                     if (DEBUG_PROVIDER) Slog.v(TAG,
4909                             "releaseProvider: stable ref count already 0, how?");
4910                     return false;
4911                 }
4912                 prc.stableCount -= 1;
4913                 if (prc.stableCount == 0) {
4914                     // What we do at this point depends on whether there are
4915                     // any unstable refs left: if there are, we just tell the
4916                     // activity manager to decrement its stable count; if there
4917                     // aren't, we need to enqueue this provider to be removed,
4918                     // and convert to holding a single unstable ref while
4919                     // doing so.
4920                     lastRef = prc.unstableCount == 0;
4921                     try {
4922                         if (DEBUG_PROVIDER) {
4923                             Slog.v(TAG, "releaseProvider: No longer stable w/lastRef="
4924                                     + lastRef + " - " + prc.holder.info.name);
4925                         }
4926                         ActivityManagerNative.getDefault().refContentProvider(
4927                                 prc.holder.connection, -1, lastRef ? 1 : 0);
4928                     } catch (RemoteException e) {
4929                         //do nothing content provider object is dead any way
4930                     }
4931                 }
4932             } else {
4933                 if (prc.unstableCount == 0) {
4934                     if (DEBUG_PROVIDER) Slog.v(TAG,
4935                             "releaseProvider: unstable ref count already 0, how?");
4936                     return false;
4937                 }
4938                 prc.unstableCount -= 1;
4939                 if (prc.unstableCount == 0) {
4940                     // If this is the last reference, we need to enqueue
4941                     // this provider to be removed instead of telling the
4942                     // activity manager to remove it at this point.
4943                     lastRef = prc.stableCount == 0;
4944                     if (!lastRef) {
4945                         try {
4946                             if (DEBUG_PROVIDER) {
4947                                 Slog.v(TAG, "releaseProvider: No longer unstable - "
4948                                         + prc.holder.info.name);
4949                             }
4950                             ActivityManagerNative.getDefault().refContentProvider(
4951                                     prc.holder.connection, 0, -1);
4952                         } catch (RemoteException e) {
4953                             //do nothing content provider object is dead any way
4954                         }
4955                     }
4956                 }
4957             }
4958 
4959             if (lastRef) {
4960                 if (!prc.removePending) {
4961                     // Schedule the actual remove asynchronously, since we don't know the context
4962                     // this will be called in.
4963                     // TODO: it would be nice to post a delayed message, so
4964                     // if we come back and need the same provider quickly
4965                     // we will still have it available.
4966                     if (DEBUG_PROVIDER) {
4967                         Slog.v(TAG, "releaseProvider: Enqueueing pending removal - "
4968                                 + prc.holder.info.name);
4969                     }
4970                     prc.removePending = true;
4971                     Message msg = mH.obtainMessage(H.REMOVE_PROVIDER, prc);
4972                     mH.sendMessage(msg);
4973                 } else {
4974                     Slog.w(TAG, "Duplicate remove pending of provider " + prc.holder.info.name);
4975                 }
4976             }
4977             return true;
4978         }
4979     }
4980 
completeRemoveProvider(ProviderRefCount prc)4981     final void completeRemoveProvider(ProviderRefCount prc) {
4982         synchronized (mProviderMap) {
4983             if (!prc.removePending) {
4984                 // There was a race!  Some other client managed to acquire
4985                 // the provider before the removal was completed.
4986                 // Abort the removal.  We will do it later.
4987                 if (DEBUG_PROVIDER) Slog.v(TAG, "completeRemoveProvider: lost the race, "
4988                         + "provider still in use");
4989                 return;
4990             }
4991 
4992             // More complicated race!! Some client managed to acquire the
4993             // provider and release it before the removal was completed.
4994             // Continue the removal, and abort the next remove message.
4995             prc.removePending = false;
4996 
4997             final IBinder jBinder = prc.holder.provider.asBinder();
4998             ProviderRefCount existingPrc = mProviderRefCountMap.get(jBinder);
4999             if (existingPrc == prc) {
5000                 mProviderRefCountMap.remove(jBinder);
5001             }
5002 
5003             for (int i=mProviderMap.size()-1; i>=0; i--) {
5004                 ProviderClientRecord pr = mProviderMap.valueAt(i);
5005                 IBinder myBinder = pr.mProvider.asBinder();
5006                 if (myBinder == jBinder) {
5007                     mProviderMap.removeAt(i);
5008                 }
5009             }
5010         }
5011 
5012         try {
5013             if (DEBUG_PROVIDER) {
5014                 Slog.v(TAG, "removeProvider: Invoking ActivityManagerNative."
5015                         + "removeContentProvider(" + prc.holder.info.name + ")");
5016             }
5017             ActivityManagerNative.getDefault().removeContentProvider(
5018                     prc.holder.connection, false);
5019         } catch (RemoteException e) {
5020             //do nothing content provider object is dead any way
5021         }
5022     }
5023 
handleUnstableProviderDied(IBinder provider, boolean fromClient)5024     final void handleUnstableProviderDied(IBinder provider, boolean fromClient) {
5025         synchronized (mProviderMap) {
5026             handleUnstableProviderDiedLocked(provider, fromClient);
5027         }
5028     }
5029 
handleUnstableProviderDiedLocked(IBinder provider, boolean fromClient)5030     final void handleUnstableProviderDiedLocked(IBinder provider, boolean fromClient) {
5031         ProviderRefCount prc = mProviderRefCountMap.get(provider);
5032         if (prc != null) {
5033             if (DEBUG_PROVIDER) Slog.v(TAG, "Cleaning up dead provider "
5034                     + provider + " " + prc.holder.info.name);
5035             mProviderRefCountMap.remove(provider);
5036             for (int i=mProviderMap.size()-1; i>=0; i--) {
5037                 ProviderClientRecord pr = mProviderMap.valueAt(i);
5038                 if (pr != null && pr.mProvider.asBinder() == provider) {
5039                     Slog.i(TAG, "Removing dead content provider:" + pr.mProvider.toString());
5040                     mProviderMap.removeAt(i);
5041                 }
5042             }
5043 
5044             if (fromClient) {
5045                 // We found out about this due to execution in our client
5046                 // code.  Tell the activity manager about it now, to ensure
5047                 // that the next time we go to do anything with the provider
5048                 // it knows it is dead (so we don't race with its death
5049                 // notification).
5050                 try {
5051                     ActivityManagerNative.getDefault().unstableProviderDied(
5052                             prc.holder.connection);
5053                 } catch (RemoteException e) {
5054                     //do nothing content provider object is dead any way
5055                 }
5056             }
5057         }
5058     }
5059 
appNotRespondingViaProvider(IBinder provider)5060     final void appNotRespondingViaProvider(IBinder provider) {
5061         synchronized (mProviderMap) {
5062             ProviderRefCount prc = mProviderRefCountMap.get(provider);
5063             if (prc != null) {
5064                 try {
5065                     ActivityManagerNative.getDefault()
5066                             .appNotRespondingViaProvider(prc.holder.connection);
5067                 } catch (RemoteException e) {
5068                 }
5069             }
5070         }
5071     }
5072 
installProviderAuthoritiesLocked(IContentProvider provider, ContentProvider localProvider, IActivityManager.ContentProviderHolder holder)5073     private ProviderClientRecord installProviderAuthoritiesLocked(IContentProvider provider,
5074             ContentProvider localProvider, IActivityManager.ContentProviderHolder holder) {
5075         final String auths[] = holder.info.authority.split(";");
5076         final int userId = UserHandle.getUserId(holder.info.applicationInfo.uid);
5077 
5078         final ProviderClientRecord pcr = new ProviderClientRecord(
5079                 auths, provider, localProvider, holder);
5080         for (String auth : auths) {
5081             final ProviderKey key = new ProviderKey(auth, userId);
5082             final ProviderClientRecord existing = mProviderMap.get(key);
5083             if (existing != null) {
5084                 Slog.w(TAG, "Content provider " + pcr.mHolder.info.name
5085                         + " already published as " + auth);
5086             } else {
5087                 mProviderMap.put(key, pcr);
5088             }
5089         }
5090         return pcr;
5091     }
5092 
5093     /**
5094      * Installs the provider.
5095      *
5096      * Providers that are local to the process or that come from the system server
5097      * may be installed permanently which is indicated by setting noReleaseNeeded to true.
5098      * Other remote providers are reference counted.  The initial reference count
5099      * for all reference counted providers is one.  Providers that are not reference
5100      * counted do not have a reference count (at all).
5101      *
5102      * This method detects when a provider has already been installed.  When this happens,
5103      * it increments the reference count of the existing provider (if appropriate)
5104      * and returns the existing provider.  This can happen due to concurrent
5105      * attempts to acquire the same provider.
5106      */
installProvider(Context context, IActivityManager.ContentProviderHolder holder, ProviderInfo info, boolean noisy, boolean noReleaseNeeded, boolean stable)5107     private IActivityManager.ContentProviderHolder installProvider(Context context,
5108             IActivityManager.ContentProviderHolder holder, ProviderInfo info,
5109             boolean noisy, boolean noReleaseNeeded, boolean stable) {
5110         ContentProvider localProvider = null;
5111         IContentProvider provider;
5112         if (holder == null || holder.provider == null) {
5113             if (DEBUG_PROVIDER || noisy) {
5114                 Slog.d(TAG, "Loading provider " + info.authority + ": "
5115                         + info.name);
5116             }
5117             Context c = null;
5118             ApplicationInfo ai = info.applicationInfo;
5119             if (context.getPackageName().equals(ai.packageName)) {
5120                 c = context;
5121             } else if (mInitialApplication != null &&
5122                     mInitialApplication.getPackageName().equals(ai.packageName)) {
5123                 c = mInitialApplication;
5124             } else {
5125                 try {
5126                     c = context.createPackageContext(ai.packageName,
5127                             Context.CONTEXT_INCLUDE_CODE);
5128                 } catch (PackageManager.NameNotFoundException e) {
5129                     // Ignore
5130                 }
5131             }
5132             if (c == null) {
5133                 Slog.w(TAG, "Unable to get context for package " +
5134                       ai.packageName +
5135                       " while loading content provider " +
5136                       info.name);
5137                 return null;
5138             }
5139             try {
5140                 final java.lang.ClassLoader cl = c.getClassLoader();
5141                 localProvider = (ContentProvider)cl.
5142                     loadClass(info.name).newInstance();
5143                 provider = localProvider.getIContentProvider();
5144                 if (provider == null) {
5145                     Slog.e(TAG, "Failed to instantiate class " +
5146                           info.name + " from sourceDir " +
5147                           info.applicationInfo.sourceDir);
5148                     return null;
5149                 }
5150                 if (DEBUG_PROVIDER) Slog.v(
5151                     TAG, "Instantiating local provider " + info.name);
5152                 // XXX Need to create the correct context for this provider.
5153                 localProvider.attachInfo(c, info);
5154             } catch (java.lang.Exception e) {
5155                 if (!mInstrumentation.onException(null, e)) {
5156                     throw new RuntimeException(
5157                             "Unable to get provider " + info.name
5158                             + ": " + e.toString(), e);
5159                 }
5160                 return null;
5161             }
5162         } else {
5163             provider = holder.provider;
5164             if (DEBUG_PROVIDER) Slog.v(TAG, "Installing external provider " + info.authority + ": "
5165                     + info.name);
5166         }
5167 
5168         IActivityManager.ContentProviderHolder retHolder;
5169 
5170         synchronized (mProviderMap) {
5171             if (DEBUG_PROVIDER) Slog.v(TAG, "Checking to add " + provider
5172                     + " / " + info.name);
5173             IBinder jBinder = provider.asBinder();
5174             if (localProvider != null) {
5175                 ComponentName cname = new ComponentName(info.packageName, info.name);
5176                 ProviderClientRecord pr = mLocalProvidersByName.get(cname);
5177                 if (pr != null) {
5178                     if (DEBUG_PROVIDER) {
5179                         Slog.v(TAG, "installProvider: lost the race, "
5180                                 + "using existing local provider");
5181                     }
5182                     provider = pr.mProvider;
5183                 } else {
5184                     holder = new IActivityManager.ContentProviderHolder(info);
5185                     holder.provider = provider;
5186                     holder.noReleaseNeeded = true;
5187                     pr = installProviderAuthoritiesLocked(provider, localProvider, holder);
5188                     mLocalProviders.put(jBinder, pr);
5189                     mLocalProvidersByName.put(cname, pr);
5190                 }
5191                 retHolder = pr.mHolder;
5192             } else {
5193                 ProviderRefCount prc = mProviderRefCountMap.get(jBinder);
5194                 if (prc != null) {
5195                     if (DEBUG_PROVIDER) {
5196                         Slog.v(TAG, "installProvider: lost the race, updating ref count");
5197                     }
5198                     // We need to transfer our new reference to the existing
5199                     // ref count, releasing the old one...  but only if
5200                     // release is needed (that is, it is not running in the
5201                     // system process).
5202                     if (!noReleaseNeeded) {
5203                         incProviderRefLocked(prc, stable);
5204                         try {
5205                             ActivityManagerNative.getDefault().removeContentProvider(
5206                                     holder.connection, stable);
5207                         } catch (RemoteException e) {
5208                             //do nothing content provider object is dead any way
5209                         }
5210                     }
5211                 } else {
5212                     ProviderClientRecord client = installProviderAuthoritiesLocked(
5213                             provider, localProvider, holder);
5214                     if (noReleaseNeeded) {
5215                         prc = new ProviderRefCount(holder, client, 1000, 1000);
5216                     } else {
5217                         prc = stable
5218                                 ? new ProviderRefCount(holder, client, 1, 0)
5219                                 : new ProviderRefCount(holder, client, 0, 1);
5220                     }
5221                     mProviderRefCountMap.put(jBinder, prc);
5222                 }
5223                 retHolder = prc.holder;
5224             }
5225         }
5226 
5227         return retHolder;
5228     }
5229 
attach(boolean system)5230     private void attach(boolean system) {
5231         sCurrentActivityThread = this;
5232         mSystemThread = system;
5233         if (!system) {
5234             ViewRootImpl.addFirstDrawHandler(new Runnable() {
5235                 @Override
5236                 public void run() {
5237                     ensureJitEnabled();
5238                 }
5239             });
5240             android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
5241                                                     UserHandle.myUserId());
5242             RuntimeInit.setApplicationObject(mAppThread.asBinder());
5243             final IActivityManager mgr = ActivityManagerNative.getDefault();
5244             try {
5245                 mgr.attachApplication(mAppThread);
5246             } catch (RemoteException ex) {
5247                 // Ignore
5248             }
5249             // Watch for getting close to heap limit.
5250             BinderInternal.addGcWatcher(new Runnable() {
5251                 @Override public void run() {
5252                     if (!mSomeActivitiesChanged) {
5253                         return;
5254                     }
5255                     Runtime runtime = Runtime.getRuntime();
5256                     long dalvikMax = runtime.maxMemory();
5257                     long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();
5258                     if (dalvikUsed > ((3*dalvikMax)/4)) {
5259                         if (DEBUG_MEMORY_TRIM) Slog.d(TAG, "Dalvik max=" + (dalvikMax/1024)
5260                                 + " total=" + (runtime.totalMemory()/1024)
5261                                 + " used=" + (dalvikUsed/1024));
5262                         mSomeActivitiesChanged = false;
5263                         try {
5264                             mgr.releaseSomeActivities(mAppThread);
5265                         } catch (RemoteException e) {
5266                         }
5267                     }
5268                 }
5269             });
5270         } else {
5271             // Don't set application object here -- if the system crashes,
5272             // we can't display an alert, we just want to die die die.
5273             android.ddm.DdmHandleAppName.setAppName("system_process",
5274                     UserHandle.myUserId());
5275             try {
5276                 mInstrumentation = new Instrumentation();
5277                 ContextImpl context = ContextImpl.createAppContext(
5278                         this, getSystemContext().mPackageInfo);
5279                 mInitialApplication = context.mPackageInfo.makeApplication(true, null);
5280                 mInitialApplication.onCreate();
5281             } catch (Exception e) {
5282                 throw new RuntimeException(
5283                         "Unable to instantiate Application():" + e.toString(), e);
5284             }
5285         }
5286 
5287         // add dropbox logging to libcore
5288         DropBox.setReporter(new DropBoxReporter());
5289 
5290         ViewRootImpl.addConfigCallback(new ComponentCallbacks2() {
5291             @Override
5292             public void onConfigurationChanged(Configuration newConfig) {
5293                 synchronized (mResourcesManager) {
5294                     // We need to apply this change to the resources
5295                     // immediately, because upon returning the view
5296                     // hierarchy will be informed about it.
5297                     if (mResourcesManager.applyConfigurationToResourcesLocked(newConfig, null)) {
5298                         // This actually changed the resources!  Tell
5299                         // everyone about it.
5300                         if (mPendingConfiguration == null ||
5301                                 mPendingConfiguration.isOtherSeqNewer(newConfig)) {
5302                             mPendingConfiguration = newConfig;
5303 
5304                             sendMessage(H.CONFIGURATION_CHANGED, newConfig);
5305                         }
5306                     }
5307                 }
5308             }
5309             @Override
5310             public void onLowMemory() {
5311             }
5312             @Override
5313             public void onTrimMemory(int level) {
5314             }
5315         });
5316     }
5317 
systemMain()5318     public static ActivityThread systemMain() {
5319         // The system process on low-memory devices do not get to use hardware
5320         // accelerated drawing, since this can add too much overhead to the
5321         // process.
5322         if (!ActivityManager.isHighEndGfx()) {
5323             HardwareRenderer.disable(true);
5324         } else {
5325             HardwareRenderer.enableForegroundTrimming();
5326         }
5327         ActivityThread thread = new ActivityThread();
5328         thread.attach(true);
5329         return thread;
5330     }
5331 
installSystemProviders(List<ProviderInfo> providers)5332     public final void installSystemProviders(List<ProviderInfo> providers) {
5333         if (providers != null) {
5334             installContentProviders(mInitialApplication, providers);
5335         }
5336     }
5337 
getIntCoreSetting(String key, int defaultValue)5338     public int getIntCoreSetting(String key, int defaultValue) {
5339         synchronized (mResourcesManager) {
5340             if (mCoreSettings != null) {
5341                 return mCoreSettings.getInt(key, defaultValue);
5342             }
5343             return defaultValue;
5344         }
5345     }
5346 
5347     private static class EventLoggingReporter implements EventLogger.Reporter {
5348         @Override
report(int code, Object... list)5349         public void report (int code, Object... list) {
5350             EventLog.writeEvent(code, list);
5351         }
5352     }
5353 
5354     private class DropBoxReporter implements DropBox.Reporter {
5355 
5356         private DropBoxManager dropBox;
5357 
DropBoxReporter()5358         public DropBoxReporter() {}
5359 
5360         @Override
addData(String tag, byte[] data, int flags)5361         public void addData(String tag, byte[] data, int flags) {
5362             ensureInitialized();
5363             dropBox.addData(tag, data, flags);
5364         }
5365 
5366         @Override
addText(String tag, String data)5367         public void addText(String tag, String data) {
5368             ensureInitialized();
5369             dropBox.addText(tag, data);
5370         }
5371 
ensureInitialized()5372         private synchronized void ensureInitialized() {
5373             if (dropBox == null) {
5374                 dropBox = (DropBoxManager) getSystemContext().getSystemService(Context.DROPBOX_SERVICE);
5375             }
5376         }
5377     }
5378 
main(String[] args)5379     public static void main(String[] args) {
5380         Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
5381         SamplingProfilerIntegration.start();
5382 
5383         // CloseGuard defaults to true and can be quite spammy.  We
5384         // disable it here, but selectively enable it later (via
5385         // StrictMode) on debug builds, but using DropBox, not logs.
5386         CloseGuard.setEnabled(false);
5387 
5388         Environment.initForCurrentUser();
5389 
5390         // Set the reporter for event logging in libcore
5391         EventLogger.setReporter(new EventLoggingReporter());
5392 
5393         AndroidKeyStoreProvider.install();
5394 
5395         // Make sure TrustedCertificateStore looks in the right place for CA certificates
5396         final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
5397         TrustedCertificateStore.setDefaultUserDirectory(configDir);
5398 
5399         Process.setArgV0("<pre-initialized>");
5400 
5401         Looper.prepareMainLooper();
5402 
5403         ActivityThread thread = new ActivityThread();
5404         thread.attach(false);
5405 
5406         if (sMainThreadHandler == null) {
5407             sMainThreadHandler = thread.getHandler();
5408         }
5409 
5410         if (false) {
5411             Looper.myLooper().setMessageLogging(new
5412                     LogPrinter(Log.DEBUG, "ActivityThread"));
5413         }
5414 
5415         // End of event ActivityThreadMain.
5416         Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
5417         Looper.loop();
5418 
5419         throw new RuntimeException("Main thread loop unexpectedly exited");
5420     }
5421 }
5422