void run() throws RemoteException {try {printMessageForState();mAm.setActivityController(this);mState = STATE_NORMAL;InputStreamReader converter = new InputStreamReader(System.in);BufferedReader in = new BufferedReader(converter);String line;while ((line = in.readLine()) != null) {boolean addNewline = true;if (line.length() <= 0) {addNewline = false;} else if ("q".equals(line) || "quit".equals(line)) {resumeController(RESULT_DEFAULT);break;} else if (mState == STATE_CRASHED) {if ("c".equals(line) || "continue".equals(line)) {resumeController(RESULT_CRASH_DIALOG);} else if ("k".equals(line) || "kill".equals(line)) {resumeController(RESULT_CRASH_KILL);} else {System.out.println("Invalid command: " + line);}} else if (mState == STATE_ANR) {if ("c".equals(line) || "continue".equals(line)) {resumeController(RESULT_ANR_DIALOG);} else if ("k".equals(line) || "kill".equals(line)) {resumeController(RESULT_ANR_KILL);} else if ("w".equals(line) || "wait".equals(line)) {resumeController(RESULT_ANR_WAIT);} else {System.out.println("Invalid command: " + line);}} else if (mState == STATE_EARLY_ANR) {if ("c".equals(line) || "continue".equals(line)) {resumeController(RESULT_EARLY_ANR_CONTINUE);} else if ("k".equals(line) || "kill".equals(line)) {resumeController(RESULT_EARLY_ANR_KILL);} else {System.out.println("Invalid command: " + line);}} else {System.out.println("Invalid command: " + line);}synchronized (this) {if (addNewline) {System.out.println("");}printMessageForState();}}} catch (IOException e) {e.printStackTrace();} finally {mAm.setActivityController(null);}
}

private void runStart() throws Exception {Intent intent = makeIntent(UserHandle.USER_CURRENT);if (mUserId == UserHandle.USER_ALL) {System.err.println("Error: Can't start service with user 'all'");return;}String mimeType = intent.getType();if (mimeType == null && intent.getData() != null&& "content".equals(intent.getData().getScheme())) {mimeType = mAm.getProviderMimeType(intent.getData(), mUserId);}do {if (mStopOption) {String packageName;if (intent.getComponent() != null) {packageName = intent.getComponent().getPackageName();} else {IPackageManager pm = IPackageManager.Stub.asInterface(ServiceManager.getService("package"));if (pm == null) {System.err.println("Error: Package manager not running; aborting");return;}List<ResolveInfo> activities = pm.queryIntentActivities(intent, mimeType, 0,mUserId);if (activities == null || activities.size() <= 0) {System.err.println("Error: Intent does not match any activities: "+ intent);return;} else if (activities.size() > 1) {System.err.println("Error: Intent matches multiple activities; can't stop: "+ intent);return;}packageName = activities.get(0).activityInfo.packageName;}System.out.println("Stopping: " + packageName);mAm.forceStopPackage(packageName, mUserId);Thread.sleep(250);}System.out.println("Starting: " + intent);intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);ParcelFileDescriptor fd = null;ProfilerInfo profilerInfo = null;if (mProfileFile != null) {try {fd = openForSystemServer(new File(mProfileFile),ParcelFileDescriptor.MODE_CREATE |ParcelFileDescriptor.MODE_TRUNCATE |ParcelFileDescriptor.MODE_READ_WRITE);} catch (FileNotFoundException e) {System.err.println("Error: Unable to open file: " + mProfileFile);System.err.println("Consider using a file under /data/local/tmp/");return;}profilerInfo = new ProfilerInfo(mProfileFile, fd, mSamplingInterval, mAutoStop);}IActivityManager.WaitResult result = null;int res;final long startTime = SystemClock.uptimeMillis();if (mWaitOption) {result = mAm.startActivityAndWait(null, null, intent, mimeType,null, null, 0, mStartFlags, profilerInfo, null, mUserId);res = result.result;} else {res = mAm.startActivityAsUser(null, null, intent, mimeType,null, null, 0, mStartFlags, profilerInfo, null, mUserId);}final long endTime = SystemClock.uptimeMillis();PrintStream out = mWaitOption ? System.out : System.err;boolean launched = false;switch (res) {case ActivityManager.START_SUCCESS:launched = true;break;case ActivityManager.START_SWITCHES_CANCELED:launched = true;out.println("Warning: Activity not started because the "+ " current activity is being kept for the user.");break;case ActivityManager.START_DELIVERED_TO_TOP:launched = true;out.println("Warning: Activity not started, intent has "+ "been delivered to currently running "+ "top-most instance.");break;case ActivityManager.START_RETURN_INTENT_TO_CALLER:launched = true;out.println("Warning: Activity not started because intent "+ "should be handled by the caller");break;case ActivityManager.START_TASK_TO_FRONT:launched = true;out.println("Warning: Activity not started, its current "+ "task has been brought to the front");break;case ActivityManager.START_INTENT_NOT_RESOLVED:out.println("Error: Activity not started, unable to "+ "resolve " + intent.toString());break;case ActivityManager.START_CLASS_NOT_FOUND:out.println(NO_CLASS_ERROR_CODE);out.println("Error: Activity class " +intent.getComponent().toShortString()+ " does not exist.");break;case ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT:out.println("Error: Activity not started, you requested to "+ "both forward and receive its result");break;case ActivityManager.START_PERMISSION_DENIED:out.println("Error: Activity not started, you do not "+ "have permission to access it.");break;case ActivityManager.START_NOT_VOICE_COMPATIBLE:out.println("Error: Activity not started, voice control not allowed for: "+ intent);break;case ActivityManager.START_NOT_CURRENT_USER_ACTIVITY:out.println("Error: Not allowed to start background user activity"+ " that shouldn't be displayed for all users.");break;default:out.println("Error: Activity not started, unknown error code " + res);break;}if (mWaitOption && launched) {if (result == null) {result = new IActivityManager.WaitResult();result.who = intent.getComponent();}System.out.println("Status: " + (result.timeout ? "timeout" : "ok"));if (result.who != null) {System.out.println("Activity: " + result.who.flattenToShortString());}if (result.thisTime >= 0) {System.out.println("ThisTime: " + result.thisTime);}if (result.totalTime >= 0) {System.out.println("TotalTime: " + result.totalTime);}System.out.println("WaitTime: " + (endTime-startTime));System.out.println("Complete");}mRepeat--;if (mRepeat > 1) {mAm.unhandledBack();}} while (mRepeat > 1);
}

@Override
public final WaitResult startActivityAndWait(IApplicationThread caller, String callingPackage,Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,int startFlags, ProfilerInfo profilerInfo, Bundle options, int userId) {enforceNotIsolatedCaller("startActivityAndWait");userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,false, ALLOW_FULL_ONLY, "startActivityAndWait", null);WaitResult res = new WaitResult();// TODO: Switch to user app stacks here.mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent, resolvedType,null, null, resultTo, resultWho, requestCode, startFlags, profilerInfo, res, null,options, false, userId, null, null);return res;
}

final void startActivityLocked(ActivityRecord r, boolean newTask,boolean doResume, boolean keepCurTransition, Bundle options) {TaskRecord rTask = r.task;final int taskId = rTask.taskId;// mLaunchTaskBehind tasks get placed at the back of the task stack.if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {// Last activity in task had been removed or ActivityManagerService is reusing task.// Insert or replace.// Might not even be in.
        insertTaskAtTop(rTask, r);mWindowManager.moveTaskToTop(taskId);}TaskRecord task = null;if (!newTask) {// If starting in an existing task, find where that is...boolean startIt = true;for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {task = mTaskHistory.get(taskNdx);if (task.getTopActivity() == null) {// All activities in task are finishing.continue;}if (task == r.task) {// Here it is!  Now, if this is not yet visible to the// user, then just add it without starting; it will// get started when the user navigates back to it.if (!startIt) {if (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to task "+ task, new RuntimeException("here").fillInStackTrace());task.addActivityToTop(r);r.putInHistory();mWindowManager.addAppToken(task.mActivities.indexOf(r), r.appToken,r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,(r.info.flags & ActivityInfo.FLAG_SHOW_FOR_ALL_USERS) != 0,r.userId, r.info.configChanges, task.voiceSession != null,r.mLaunchTaskBehind);if (VALIDATE_TOKENS) {validateAppTokensLocked();}ActivityOptions.abort(options);return;}break;} else if (task.numFullscreen > 0) {startIt = false;}}}// Place a new activity at top of stack, so it is next to interact// with the user.// If we are not placing the new activity frontmost, we do not want// to deliver the onUserLeaving callback to the actual frontmost// activityif (task == r.task && mTaskHistory.indexOf(task) != (mTaskHistory.size() - 1)) {mStackSupervisor.mUserLeaving = false;if (DEBUG_USER_LEAVING) Slog.v(TAG_USER_LEAVING,"startActivity() behind front, mUserLeaving=false");}task = r.task;// Slot the activity into the history stack and proceedif (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to stack to task " + task,new RuntimeException("here").fillInStackTrace());task.addActivityToTop(r);task.setFrontOfTask();r.putInHistory();if (!isHomeStack() || numActivities() > 0) {// We want to show the starting preview window if we are// switching to a new task, or the next activity's process is// not currently running.boolean showStartingIcon = newTask;ProcessRecord proc = r.app;if (proc == null) {proc = mService.mProcessNames.get(r.processName, r.info.applicationInfo.uid);}if (proc == null || proc.thread == null) {showStartingIcon = true;}if (DEBUG_TRANSITION) Slog.v(TAG_TRANSITION,"Prepare open transition: starting " + r);if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_ANIMATION) != 0) {mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, keepCurTransition);mNoAnimActivities.add(r);} else {mWindowManager.prepareAppTransition(newTask? r.mLaunchTaskBehind? AppTransition.TRANSIT_TASK_OPEN_BEHIND: AppTransition.TRANSIT_TASK_OPEN: AppTransition.TRANSIT_ACTIVITY_OPEN, keepCurTransition);mNoAnimActivities.remove(r);}mWindowManager.addAppToken(task.mActivities.indexOf(r),r.appToken, r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,(r.info.flags & ActivityInfo.FLAG_SHOW_FOR_ALL_USERS) != 0, r.userId,r.info.configChanges, task.voiceSession != null, r.mLaunchTaskBehind);boolean doShow = true;if (newTask) {// Even though this activity is starting fresh, we still need// to reset it to make sure we apply affinities to move any// existing activities from other tasks in to it.// If the caller has requested that the target task be// reset, then do so.if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {resetTaskIfNeededLocked(r, r);doShow = topRunningNonDelayedActivityLocked(null) == r;}} else if (options != null && new ActivityOptions(options).getAnimationType()== ActivityOptions.ANIM_SCENE_TRANSITION) {doShow = false;}if (r.mLaunchTaskBehind) {// Don't do a starting window for mLaunchTaskBehind. More importantly make sure we// tell WindowManager that r is visible even though it is at the back of the stack.mWindowManager.setAppVisibility(r.appToken, true);ensureActivitiesVisibleLocked(null, 0);} else if (SHOW_APP_STARTING_PREVIEW && doShow) {// Figure out if we are transitioning from another activity that is// "has the same starting icon" as the next one.  This allows the// window manager to keep the previous window it had previously// created, if it still had one.ActivityRecord prev = mResumedActivity;if (prev != null) {// We don't want to reuse the previous starting preview if:// (1) The current activity is in a different task.if (prev.task != r.task) {prev = null;}// (2) The current activity is already displayed.else if (prev.nowVisible) {prev = null;}}mWindowManager.setAppStartingWindow(r.appToken, r.packageName, r.theme,mService.compatibilityInfoForPackageLocked(r.info.applicationInfo), r.nonLocalizedLabel,r.labelRes, r.icon, r.logo, r.windowFlags,prev != null ? prev.appToken : null, showStartingIcon);r.mStartingWindowShown = true;}} else {// If this is the first activity, don't do any fancy animations,// because there is nothing for it to animate on top of.
        mWindowManager.addAppToken(task.mActivities.indexOf(r), r.appToken,r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,(r.info.flags & ActivityInfo.FLAG_SHOW_FOR_ALL_USERS) != 0, r.userId,r.info.configChanges, task.voiceSession != null, r.mLaunchTaskBehind);ActivityOptions.abort(options);options = null;}if (VALIDATE_TOKENS) {validateAppTokensLocked();}if (doResume) {mStackSupervisor.resumeTopActivitiesLocked(this, r, options);}
}

@Override
public void stopAppSwitches() {if (checkCallingPermission(android.Manifest.permission.STOP_APP_SWITCHES)!= PackageManager.PERMISSION_GRANTED) {throw new SecurityException("Requires permission "+ android.Manifest.permission.STOP_APP_SWITCHES);}synchronized(this) {mAppSwitchesAllowedTime = SystemClock.uptimeMillis()+ APP_SWITCH_DELAY_TIME;mDidAppSwitch = false;mHandler.removeMessages(DO_PENDING_ACTIVITY_LAUNCHES_MSG);Message msg = mHandler.obtainMessage(DO_PENDING_ACTIVITY_LAUNCHES_MSG);mHandler.sendMessageDelayed(msg, APP_SWITCH_DELAY_TIME);}
}

public void resumeAppSwitches() {if (checkCallingPermission(android.Manifest.permission.STOP_APP_SWITCHES)!= PackageManager.PERMISSION_GRANTED) {throw new SecurityException("Requires permission "+ android.Manifest.permission.STOP_APP_SWITCHES);}synchronized(this) {// Note that we don't execute any pending app switches... we will// let those wait until either the timeout, or the next start// activity request.mAppSwitchesAllowedTime = 0;}
}

final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {if (mStackSupervisor.inResumeTopActivity) {// Don't even start recursing.return false;}boolean result = false;try {// Protect against recursion.mStackSupervisor.inResumeTopActivity = true;if (mService.mLockScreenShown == ActivityManagerService.LOCK_SCREEN_LEAVING) {mService.mLockScreenShown = ActivityManagerService.LOCK_SCREEN_HIDDEN;mService.updateSleepIfNeededLocked();}result = resumeTopActivityInnerLocked(prev, options);} finally {mStackSupervisor.inResumeTopActivity = false;}return result;
}

private final void startProcessLocked(ProcessRecord app, String hostingType,String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {long startTime = SystemClock.elapsedRealtime();if (app.pid > 0 && app.pid != MY_PID) {checkTime(startTime, "startProcess: removing from pids map");synchronized (mPidsSelfLocked) {mPidsSelfLocked.remove(app.pid);mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);}checkTime(startTime, "startProcess: done removing from pids map");app.setPid(0);}if (DEBUG_PROCESSES && mProcessesOnHold.contains(app)) Slog.v(TAG_PROCESSES,"startProcessLocked removing on hold: " + app);mProcessesOnHold.remove(app);checkTime(startTime, "startProcess: starting to update cpu stats");updateCpuStats();checkTime(startTime, "startProcess: done updating cpu stats");try {try {if (AppGlobals.getPackageManager().isPackageFrozen(app.info.packageName)) {// This is caught below as if we had failed to fork zygotethrow new RuntimeException("Package " + app.info.packageName + " is frozen!");}} catch (RemoteException e) {throw e.rethrowAsRuntimeException();}int uid = app.uid;int[] gids = null;int mountExternal = Zygote.MOUNT_EXTERNAL_NONE;if (!app.isolated) {int[] permGids = null;try {checkTime(startTime, "startProcess: getting gids from package manager");final IPackageManager pm = AppGlobals.getPackageManager();permGids = pm.getPackageGids(app.info.packageName, app.userId);MountServiceInternal mountServiceInternal = LocalServices.getService(MountServiceInternal.class);mountExternal = mountServiceInternal.getExternalStorageMountMode(uid,app.info.packageName);} catch (RemoteException e) {throw e.rethrowAsRuntimeException();}/** Add shared application and profile GIDs so applications can share some* resources like shared libraries and access user-wide resources*/if (ArrayUtils.isEmpty(permGids)) {gids = new int[2];} else {gids = new int[permGids.length + 2];System.arraycopy(permGids, 0, gids, 2, permGids.length);}gids[0] = UserHandle.getSharedAppGid(UserHandle.getAppId(uid));gids[1] = UserHandle.getUserGid(UserHandle.getUserId(uid));}checkTime(startTime, "startProcess: building args");if (mFactoryTest != FactoryTest.FACTORY_TEST_OFF) {if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL&& mTopComponent != null&& app.processName.equals(mTopComponent.getPackageName())) {uid = 0;}if (mFactoryTest == FactoryTest.FACTORY_TEST_HIGH_LEVEL&& (app.info.flags&ApplicationInfo.FLAG_FACTORY_TEST) != 0) {uid = 0;}}int debugFlags = 0;if ((app.info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {debugFlags |= Zygote.DEBUG_ENABLE_DEBUGGER;// Also turn on CheckJNI for debuggable apps. It's quite// awkward to turn on otherwise.debugFlags |= Zygote.DEBUG_ENABLE_CHECKJNI;}// Run the app in safe mode if its manifest requests so or the// system is booted in safe mode.if ((app.info.flags & ApplicationInfo.FLAG_VM_SAFE_MODE) != 0 ||mSafeMode == true) {debugFlags |= Zygote.DEBUG_ENABLE_SAFEMODE;}if ("1".equals(SystemProperties.get("debug.checkjni"))) {debugFlags |= Zygote.DEBUG_ENABLE_CHECKJNI;}String jitDebugProperty = SystemProperties.get("debug.usejit");if ("true".equals(jitDebugProperty)) {debugFlags |= Zygote.DEBUG_ENABLE_JIT;} else if (!"false".equals(jitDebugProperty)) {// If we didn't force disable by setting false, defer to the dalvik vm options.if ("true".equals(SystemProperties.get("dalvik.vm.usejit"))) {debugFlags |= Zygote.DEBUG_ENABLE_JIT;}}String genDebugInfoProperty = SystemProperties.get("debug.generate-debug-info");if ("true".equals(genDebugInfoProperty)) {debugFlags |= Zygote.DEBUG_GENERATE_DEBUG_INFO;}if ("1".equals(SystemProperties.get("debug.jni.logging"))) {debugFlags |= Zygote.DEBUG_ENABLE_JNI_LOGGING;}if ("1".equals(SystemProperties.get("debug.assert"))) {debugFlags |= Zygote.DEBUG_ENABLE_ASSERT;}String requiredAbi = (abiOverride != null) ? abiOverride : app.info.primaryCpuAbi;if (requiredAbi == null) {requiredAbi = Build.SUPPORTED_ABIS[0];}String instructionSet = null;if (app.info.primaryCpuAbi != null) {instructionSet = VMRuntime.getInstructionSet(app.info.primaryCpuAbi);}app.gids = gids;app.requiredAbi = requiredAbi;app.instructionSet = instructionSet;// Start the process.  It will either succeed and return a result containing// the PID of the new process, or else throw a RuntimeException.boolean isActivityProcess = (entryPoint == null);if (entryPoint == null) entryPoint = "android.app.ActivityThread";Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Start proc: " +app.processName);checkTime(startTime, "startProcess: asking zygote to start proc");Process.ProcessStartResult startResult = Process.start(entryPoint,app.processName, uid, uid, gids, debugFlags, mountExternal,app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,app.info.dataDir, entryPointArgs);checkTime(startTime, "startProcess: returned from zygote!");Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);if (app.isolated) {mBatteryStatsService.addIsolatedUid(app.uid, app.info.uid);}mBatteryStatsService.noteProcessStart(app.processName, app.info.uid);checkTime(startTime, "startProcess: done updating battery stats");EventLog.writeEvent(EventLogTags.AM_PROC_START,UserHandle.getUserId(uid), startResult.pid, uid,app.processName, hostingType,hostingNameStr != null ? hostingNameStr : "");if (app.persistent) {Watchdog.getInstance().processStarted(app.processName, startResult.pid);}checkTime(startTime, "startProcess: building log message");StringBuilder buf = mStringBuilder;buf.setLength(0);buf.append("Start proc ");buf.append(startResult.pid);buf.append(':');buf.append(app.processName);buf.append('/');UserHandle.formatUid(buf, uid);if (!isActivityProcess) {buf.append(" [");buf.append(entryPoint);buf.append("]");}buf.append(" for ");buf.append(hostingType);if (hostingNameStr != null) {buf.append(" ");buf.append(hostingNameStr);}Slog.i(TAG, buf.toString());app.setPid(startResult.pid);app.usingWrapper = startResult.usingWrapper;app.removed = false;app.killed = false;app.killedByAm = false;checkTime(startTime, "startProcess: starting to update pids map");synchronized (mPidsSelfLocked) {this.mPidsSelfLocked.put(startResult.pid, app);if (isActivityProcess) {Message msg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG);msg.obj = app;mHandler.sendMessageDelayed(msg, startResult.usingWrapper? PROC_START_TIMEOUT_WITH_WRAPPER : PROC_START_TIMEOUT);}}checkTime(startTime, "startProcess: done updating pids map");} catch (RuntimeException e) {// XXX do better error recovery.app.setPid(0);mBatteryStatsService.noteProcessFinish(app.processName, app.info.uid);if (app.isolated) {mBatteryStatsService.removeIsolatedUid(app.uid, app.info.uid);}Slog.e(TAG, "Failure starting process " + app.processName, e);}
}

public static void main(String[] args) {Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");SamplingProfilerIntegration.start();// CloseGuard defaults to true and can be quite spammy.  We// disable it here, but selectively enable it later (via// StrictMode) on debug builds, but using DropBox, not logs.CloseGuard.setEnabled(false);Environment.initForCurrentUser();// Set the reporter for event logging in libcoreEventLogger.setReporter(new EventLoggingReporter());AndroidKeyStoreProvider.install();// Make sure TrustedCertificateStore looks in the right place for CA certificatesfinal File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());TrustedCertificateStore.setDefaultUserDirectory(configDir);Process.setArgV0("<pre-initialized>");Looper.prepareMainLooper();ActivityThread thread = new ActivityThread();thread.attach(false);if (sMainThreadHandler == null) {sMainThreadHandler = thread.getHandler();}if (false) {Looper.myLooper().setMessageLogging(newLogPrinter(Log.DEBUG, "ActivityThread"));}// End of event ActivityThreadMain.
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);Looper.loop();throw new RuntimeException("Main thread loop unexpectedly exited");
}

private void attach(boolean system) {sCurrentActivityThread = this;mSystemThread = system;if (!system) {ViewRootImpl.addFirstDrawHandler(new Runnable() {@Overridepublic void run() {ensureJitEnabled();}});android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",UserHandle.myUserId());RuntimeInit.setApplicationObject(mAppThread.asBinder());final IActivityManager mgr = ActivityManagerNative.getDefault();try {mgr.attachApplication(mAppThread);} catch (RemoteException ex) {// Ignore
        }// Watch for getting close to heap limit.BinderInternal.addGcWatcher(new Runnable() {@Override public void run() {if (!mSomeActivitiesChanged) {return;}Runtime runtime = Runtime.getRuntime();long dalvikMax = runtime.maxMemory();long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();if (dalvikUsed > ((3*dalvikMax)/4)) {if (DEBUG_MEMORY_TRIM) Slog.d(TAG, "Dalvik max=" + (dalvikMax/1024)+ " total=" + (runtime.totalMemory()/1024)+ " used=" + (dalvikUsed/1024));mSomeActivitiesChanged = false;try {mgr.releaseSomeActivities(mAppThread);} catch (RemoteException e) {}}}});} else {// Don't set application object here -- if the system crashes,// we can't display an alert, we just want to die die die.android.ddm.DdmHandleAppName.setAppName("system_process",UserHandle.myUserId());try {mInstrumentation = new Instrumentation();ContextImpl context = ContextImpl.createAppContext(this, getSystemContext().mPackageInfo);mInitialApplication = context.mPackageInfo.makeApplication(true, null);mInitialApplication.onCreate();} catch (Exception e) {throw new RuntimeException("Unable to instantiate Application():" + e.toString(), e);}}// add dropbox logging to libcoreDropBox.setReporter(new DropBoxReporter());ViewRootImpl.addConfigCallback(new ComponentCallbacks2() {@Overridepublic void onConfigurationChanged(Configuration newConfig) {synchronized (mResourcesManager) {// We need to apply this change to the resources// immediately, because upon returning the view// hierarchy will be informed about it.if (mResourcesManager.applyConfigurationToResourcesLocked(newConfig, null)) {// This actually changed the resources!  Tell// everyone about it.if (mPendingConfiguration == null ||mPendingConfiguration.isOtherSeqNewer(newConfig)) {mPendingConfiguration = newConfig;sendMessage(H.CONFIGURATION_CHANGED, newConfig);}}}}@Overridepublic void onLowMemory() {}@Overridepublic void onTrimMemory(int level) {}});
}

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {// If we are getting ready to gc after going to the background, well// we are back active so skip it.
    unscheduleGcIdler();mSomeActivitiesChanged = true;if (r.profilerInfo != null) {mProfiler.setProfiler(r.profilerInfo);mProfiler.startProfiling();}// Make sure we are running with the most recent config.handleConfigurationChanged(null, null);if (localLOGV) Slog.v(TAG, "Handling launch of " + r);// Initialize before creating the activity
    WindowManagerGlobal.initialize();Activity a = performLaunchActivity(r, customIntent);if (a != null) {r.createdConfig = new Configuration(mConfiguration);Bundle oldState = r.state;handleResumeActivity(r.token, false, r.isForward,!r.activity.mFinished && !r.startsNotResumed);if (!r.activity.mFinished && r.startsNotResumed) {// The activity manager actually wants this one to start out// paused, because it needs to be visible but isn't in the// foreground.  We accomplish this by going through the// normal startup (because activities expect to go through// onResume() the first time they run, before their window// is displayed), and then pausing it.  However, in this case// we do -not- need to do the full pause cycle (of freezing// and such) because the activity manager assumes it can just// retain the current state it has.try {r.activity.mCalled = false;mInstrumentation.callActivityOnPause(r.activity);// We need to keep around the original state, in case// we need to be created again.  But we only do this// for pre-Honeycomb apps, which always save their state// when pausing, so we can not have them save their state// when restarting from a paused state.  For HC and later,// we want to (and can) let the state be saved as the normal// part of stopping the activity.if (r.isPreHoneycomb()) {r.state = oldState;}if (!r.activity.mCalled) {throw new SuperNotCalledException("Activity " + r.intent.getComponent().toShortString() +" did not call through to super.onPause()");}} catch (SuperNotCalledException e) {throw e;} catch (Exception e) {if (!mInstrumentation.onException(r.activity, e)) {throw new RuntimeException("Unable to pause activity "+ r.intent.getComponent().toShortString()+ ": " + e.toString(), e);}}r.paused = true;}} else {// If there was an error, for any reason, tell the activity// manager to stop us.try {ActivityManagerNative.getDefault().finishActivity(r.token, Activity.RESULT_CANCELED, null, false);} catch (RemoteException ex) {// Ignore
        }}
}