从launch点击 logo 流程以及浅谈 ActivityManagerService

上篇文章已经讲过 ActivityManagerService 的启动时机浅谈 Zygote 和 SystemServer 一下源码都是基于Android28，android10的源码

点击launch 的 logo 流程

先说结论吧，跟着结论往下追代码

Launcher 也是一个应用，其实也是调用的 startActivity(), 通过binder跨进程向AMS发起startActivity请求
当 AMS 收到这个请求，（其实先执行当前Resume的Activity的onPause方法）当真正打开的时候，先看进程是否存在，如果不存在，AMS 通过 Socket 向 Zygote 发起创建进程的命令
创建完进程，通过反射创建ActivityThread，执行 ActivityThread 的 main() 方法。在main() 方法中向 AMS 发送 attachApplication(ApplicationThread) 请求，把 ApplicationThread 传过去，给 AMS，ApplicationThread也是个binder机制，以便 AMS 调用本app的方法
AMS 调用 ApplicationThread.bindApplication 的命令，当 ApplicationThread 收到这个命令之后，向 H（Handler）发送一个 sendMessage(H.BIND_APPLICATION, data);
H 收到这个 message，然后去处理，这时候创建了ContextImle 、Instrumentation 和 Application。然后 Instrumentation调用了 Application 的 onCreate 方法、
ActivityThread.handleBindApplication，继续走 AMS 的 attachApplicationLocked的方法，这里面又是真正打开Activity
AMS 会向发送个 ActivityThread发送一个 EXECUTE_TRANSACTION ，以前每个调用都有个message，8.0 之后统一用了一个 msg，最终会调用到 handleLaunchActivity，然后就是初始化Activity ，走Activity的生命周期

下面会讲到 Instrumentation

点击 Launcher

Launcher 也是一个应用，是个系统应用，当开机的时候PMS会把安装的所有信息记录下来，然后 Launcher 通过这个可以知道都有什么安装的应用，以及应用的信息。

// Launcher 点击logo
Launcher.startActivity()

// 然后执行到我们比较熟悉的代码，startActivity
Activity.startActivity()

Activity.startActivityForResult()

//走到 Instrumentation ，这个类是个钩子，相当于对Activity的管理，都是通过这个类,此时会把 
// IApplicationThread 当做参数，可以让 AMS 向 App 通信，准确来说，此时的 IApplicationThread 是 Launcher 页面的。
Instrumentation.execStartActivity()

// IActivityManager 是 AMS 在 咱们app的代理，相当于调到 AMS的 startActivity 方法
// 这里还返回了一个 int 值， 是否成功。比如抛出 是否在清单文件注册 的异常 都是通过这个返回值判断的
ActivityManager.getService().startActivity() 
IActivityManager.startActivity()

下面进入 AMS 的 startActivity 的方法内

// 在AMS中 调用了 ActivityTaskManagerService的方法
ActivityManagerService.startActivity()

// ActivityTaskManagerService 是 android10 以后才有的类，以后这个类来管理 Activity 
ActivityTaskManagerService.startActivity()

ActivityTaskManagerService.startActivityAsUser()
//ActivityTaskManagerService的方法。会调用到 ActivityStarter.execute()
//注意这里 这里会mRequest.mayWait 设置为true
int startActivityAsUser(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
        boolean validateIncomingUser) {
    enforceNotIsolatedCaller("startActivityAsUser");

    userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
            Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
    return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
            .setCaller(caller)
            .setCallingPackage(callingPackage)
            .setResolvedType(resolvedType)
            .setResultTo(resultTo)
            .setResultWho(resultWho)
            .setRequestCode(requestCode)
            .setStartFlags(startFlags)
            .setProfilerInfo(profilerInfo)
            .setActivityOptions(bOptions)
            //注意这里 这里会mRequest.mayWait 设置为true
            .setMayWait(userId)
            .execute();

    }
    

ActivityStarter.execute()
// 继续调用 ActivityStarter 中的方法 ， 在这个方法中创建了 ActivityRecord 对象，用来记录这个Activity
// 同时设置
ActivityStarter.startActivityMayWait()
ActivityStarter.startActivity()
// 处理一下启动模式和回退栈以及TaskRecord的情况 
ActivityStarter.startActivityUnchecked()
// 为 ActivityRecord 创建 ActivityStack
ActivityStarter.setTaskFromReuseOrCreateNewTask()

// 省略一下代码调用，蒙了
// 把当前resume的Activity 设置为 onPause()
Activity.startPausingLocked()
    mService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),
                        prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving,
                                prev.configChangeFlags, pauseImmediately));

// 这个类用来设置Activity的生命周期，这里传的参数是 PauseActivityItem
ClientLifecycleManager.scheduleTransaction()

ClientTransaction.schedule()

// 执行到 也就是 ApplicationThread 中的方法
IApplicationThread.scheduleTransaction

// 最终调用到 ActivityThread 的 scheduleTransaction
ApplicationThread.scheduleTransaction()
ActivityThread.this.scheduleTransaction(transaction);
	 sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
     
// 当 H （Handler收到这个消息）执行 这个pause
TransactionExecutor.execute(transaction)
// 当执行完Activity的onPause之后会执行 PauseActivityItem 的 postExecute()
TransactionExecutor.executeCallbacks()



// ClientTransactionHandler 中的ON_PAUSE，当创建 TransactionExecutor (ClientTransactionHandler clientTransactionHandler)
// ActivityThread 继承 ClientTransactionHandler
// 创建 TransactionExecutor 时候 
// ActivityThread 的成员变量
private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);

// 之后走到 ActivityThread的 handlePauseActivity 这个方法
ActivityThread.handlePauseActivity()

// 在这个里面 询问是否保存当前的状态 也就是 callActivityOnSaveInstanceState
ActivityThread.performPauseActivity(r, finished, reason, pendingActions);
ActivityThread.performPauseActivityIfNeeded();

// 还是通过 Instrumentation 来调用 Activity的生命周期
Instrumentation.callActivityOnPause
Activity.performPause()
Activity.onPause();

// 当这个流程走完之后，在上面的 PauseActivityItem
PauseActivityItem.postExecute()
ActivityTaskManager.getService().activityPaused(token);
ActivityTaskManagerService..activityPaused()
// 之后调用到 ActivityTask
ActivityStack.activityPausedLocked()
ActivityStack.completePauseLocked()

RootActivityContainer.resumeFocusedStacksTopActivities()
ActivityStack.resumeTopActivityUncheckedLocked()
ActivityStack.resumeTopActivityInnerLocked()

// 这个方法判断 如果还没有进程的话，就发送Handler，创建进程的Message
ActivityStackSupervisor.startSpecificActivityLocked()

// AMS 创建进程
ActivityManagerService.startProcessLocked()
ProcessList.startProcessLocked()
// 这里判断 系统进程还是用户进程
ProcessList.startProcess()
Process.start()

ZygoteProcess.start()
ZygoteProcess.startViaZygote()
ZygoteProcess.zygoteSendArgsAndGetResult()

// 这个方法了面就是去发送socket 通知 Zygote 去创建进程的 信息
//            zygoteWriter.write(msgStr);
//            zygoteWriter.flush();
ZygoteProcess.attemptZygoteSendArgsAndGetResult()

// 当进程创建完毕的时候，会通过反射 闯将ActivityThread类 走 ActivityThread的main方法
ActivityThread.main()


// 在 main() 调用 attach ，在这个里面创建了 Instrumentation 和 ContextImpl ，创建Application
ActivityThread.attach(false, startSeq);
// 同时还设置给 ActivityManagerService 发送 attachApplication 的命令，把 ApplicationThread 传过去
// 可以让AMS 调用咱们的方法
ActivityManagerService.attachApplication(mAppThread,startSeq)
// 在这个方法里  会调用 ApplicationThread的 bindApplication
ActivityManagerService.attachApplicationLocked()

// 里面 sendMessage(H.BIND_APPLICATION, data);
ApplicationThread.bindApplication()

// 在这个里面
ActivityThread.handleBindApplication()
// 执行 Application的 onCreate方法
Instrumentation.callApplicationOnCreate(app)

// 创建进程完成之后，继续走 这个里面的代码
ActivityManagerService.attachApplicationLocked()

ActivityTaskManagerInternal.attachApplication()
ActivityTaskManagerService.attachApplication()
RootActivityContainer.attachApplication(wpc)

// 这个方法在 startSpecificActivityLocked 也就是看进程是否存在的时候看到过
// 如果进程存在 直接 调用下面的方法，如果进程不存在直接 打开Activity
// 当 创建完进程之后，又走到了这个方法里
ActivityStackSupervisor.realStartActivityLocked()
// 创建 ClientTransaction，并且设置成 LaunchActivityItem
//然后 ClientLifecycleManager 又去执行了这个 LaunchActivityItem
// 剩下的过程 和  刚才的 PauseItem差不多。

启动 ActivityManagerService

Linux系统的init进程，解析init.rc，启动 Zygote 进程，在 Zygote 初始化时，启动 SystemServer 进程，在 SystemServer 创建了Android系统多个重要的服务，ActivityManagerService 就是在这里创建的即一下代码在 SystemServer 中 startBootstrapServices 方法，真正创建时在 ActivityManagerService.Lifecycle 内部类里面,调用了ActivityManagerService构造方法，并且调用start()方法，当 ActivityManagerService 启动完毕之后，通知或者启动一些系统服务或者应用，比如


// android 10 引入的 ActivityTaskManagerService 类，用来管理Activity的启动流程
 ActivityTaskManagerService atm = mSystemServiceManager.startService(
           ActivityTaskManagerService.Lifecycle.class).getService();
   mActivityManagerService = ActivityManagerService.Lifecycle.startService(
           mSystemServiceManager, atm);
   mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
   mActivityManagerService.setInstaller(installer);

public static final class Lifecycle extends SystemService {
       private final ActivityManagerService mService;
       private static ActivityTaskManagerService sAtm;

       public Lifecycle(Context context) {
           super(context);
           mService = new ActivityManagerService(context, sAtm);
       }

       public static ActivityManagerService startService(
               SystemServiceManager ssm, ActivityTaskManagerService atm) {
           sAtm = atm;
           return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
       }

       @Override
       public void onStart() {
           mService.start();
       }

       @Override
       public void onBootPhase(int phase) {
           mService.mBootPhase = phase;
           if (phase == PHASE_SYSTEM_SERVICES_READY) {
               mService.mBatteryStatsService.systemServicesReady();
               mService.mServices.systemServicesReady();
           } else if (phase == PHASE_ACTIVITY_MANAGER_READY) {
               mService.startBroadcastObservers();
           } else if (phase == PHASE_THIRD_PARTY_APPS_CAN_START) {
               mService.mPackageWatchdog.onPackagesReady();
           }
       }

       @Override
       public void onCleanupUser(int userId) {
           mService.mBatteryStatsService.onCleanupUser(userId);
       }

       public ActivityManagerService getService() {
           return mService;
       }
   }

然后我们看一下 ActivityManagerService 的构造方法

public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
   LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
   mInjector = new Injector();
   // 创建上下文环境
   mContext = systemContext;
   mFactoryTest = FactoryTest.getMode();
   // 赋值当前的 ActivityThread 
   mSystemThread = ActivityThread.currentActivityThread();
   mUiContext = mSystemThread.getSystemUiContext();

   Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
   
   // 创建 Handler 线程，用来处理 Hander消息
   mHandlerThread = new ServiceThread(TAG,
           THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
   mHandlerThread.start();
   mHandler = new MainHandler(mHandlerThread.getLooper());
   mUiHandler = mInjector.getUiHandler(this);

   mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",
           THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
   mProcStartHandlerThread.start();
   mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());

 //管理AMS的一些常量 ,比如产商，版本等等
   mConstants = new ActivityManagerConstants(mContext, this, mHandler);
   final ActiveUids activeUids = new ActiveUids(this, true /* postChangesToAtm */);
   mProcessList.init(this, activeUids);
   mLowMemDetector = new LowMemDetector(this);
   // 关于杀进程有关的
   mOomAdjuster = new OomAdjuster(this, mProcessList, activeUids);

   //下面的这两个广播队列应该就与android系统的广播实现相
   final BroadcastConstants foreConstants = new BroadcastConstants(
           Settings.Global.BROADCAST_FG_CONSTANTS);
   foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;

   final BroadcastConstants backConstants = new BroadcastConstants(
           Settings.Global.BROADCAST_BG_CONSTANTS);
   backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;

   final BroadcastConstants offloadConstants = new BroadcastConstants(
           Settings.Global.BROADCAST_OFFLOAD_CONSTANTS);
   offloadConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
   // by default, no "slow" policy in this queue
   offloadConstants.SLOW_TIME = Integer.MAX_VALUE;

   mEnableOffloadQueue = SystemProperties.getBoolean(
           "persist.device_config.activity_manager_native_boot.offload_queue_enabled", false);

   mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
           "foreground", foreConstants, false);
   mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
           "background", backConstants, true);
   mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
           "offload", offloadConstants, true);
   mBroadcastQueues[0] = mFgBroadcastQueue;
   mBroadcastQueues[1] = mBgBroadcastQueue;
   mBroadcastQueues[2] = mOffloadBroadcastQueue;

   //初始化管理 ServiceRecord 的 ActiveServices对象
   mServices = new ActiveServices(this);
   //初始化管理 ProviderMap 的 ProviderMap 对象
   mProviderMap = new ProviderMap(this);
   
   mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
   mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);

   final File systemDir = SystemServiceManager.ensureSystemDir();

   //关于电量服务的
   mBatteryStatsService = new BatteryStatsService(systemContext, systemDir,
           BackgroundThread.get().getHandler());
   mBatteryStatsService.getActiveStatistics().readLocked();
   mBatteryStatsService.scheduleWriteToDisk();
   mOnBattery = DEBUG_POWER ? true
           : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
   mBatteryStatsService.getActiveStatistics().setCallback(this);
   mOomAdjProfiler.batteryPowerChanged(mOnBattery);

   mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));

   mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);

   mUgmInternal = LocalServices.getService(UriGrantsManagerInternal.class);

   mUserController = new UserController(this);

   mPendingIntentController = new PendingIntentController(
           mHandlerThread.getLooper(), mUserController);

   if (SystemProperties.getInt("sys.use_fifo_ui", 0) != 0) {
       mUseFifoUiScheduling = true;
   }

   mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
   mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);

   mActivityTaskManager = atm;
   // 初始化 ActivityTaskManager 用来管理 Activity 
   mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
           DisplayThread.get().getLooper());
  // 省略
}

总结启动

参考

Android 10.0 系统服务之ActivityMnagerService-AMS启动流程-[Android取经之路]
一篇文章看明白 Android 从点击应用图标到界面显示的过程
 Android之ActivityManagerService详解(APP启动过程)
一个APP从启动到主页面显示经历了哪些过程？
Android 10.0 Activity启动详解(二)

从launch点击 logo 流程 以及 浅谈 ActivityManagerService