Activity启动过程分析(android-28)

最近以Android-28为基础,梳理了一下Activity的启动过程,在此做一些学习笔记。方便需要时查阅。

此次主要关注"从Laucher点击一个app图标A ,到A 启动Application和Activity"的过程

image

一、Activity启动前的进程关系

init进程：init是所有linux程序的起点，是Zygote的父进程。解析init.rc孵化出Zygote进程。
Zygote进程：Zygote是所有Java进程的父进程，所有的App进程都是由Zygote进程fork生成的。
SystemServer进程：System Server是Zygote孵化的第一个进程。SystemServer负责启动和管理整个Java framework，包含AMS，PMS等服务。
Launcher：Zygote进程孵化的第一个App进程是Launcher

1.1、什么是init进程

Android是基于linux系统的，手机开机之后，linux内核进行加载。加载完成之后会启动init进程。
init进程会启动ServiceManager，孵化一些守护进程，并解析init.rc孵化Zygote进程。

1.2、Zygote进程

所有的App进程都是由Zygote进程fork生成的，包括SystemServer进程。
Zygote初始化后，会注册一个等待接受消息的socket，OS层会采用socket进行IPC通信。

1.3、为什么是Zygote来孵化进程，而不是新建进程呢？

每个应用程序都是运行在各自的Dalvik虚拟机中，应用程序每次运行都要重新初始化和启动虚拟机，这个过程会耗费很长时间。Zygote会把已经运行的虚拟机的代码和内存信息共享。起到一个预加载资源和类的作用，从而缩短启动时间。

二、Activity启动涉及到的一些类:

2.1、ActivityRecord

ActivityRecord是Activity在system_server进程中的镜像，Activity实例与ActivityRecord实例一一对应。ActivityRecord用来存储Activity的信息，如所在的进程名称，应用的包名，所在的任务栈的taskAffinity等。

/**
 * An entry in the history stack, representing an activity.
 */
final class ActivityRecord {
    final ComponentName realActivity;  // the intent component, or target of an alias.
    final String shortComponentName; // the short component name of the intent
    final String packageName; // the package implementing intent's component
    final String processName; // process where this component wants to run
    final String taskAffinity; // as per ActivityInfo.taskAffinity
    boolean fullscreen; // covers the full screen?
}

2.2、TaskRecord

TaskRecord表示任务栈,是真正的一个先进后出的栈结构，用于记录activity开启的先后顺序。其所存放的Activity是不支持重新排序的，只能根据压栈和出栈操作更改Activity的顺序。有了TaskRecord，Android系统才能知道当一个Activity退出时，接下来该显示哪一个Activity。

final class TaskRecord {
    /** List of all activities in the task arranged in history order */
    final ArrayList mActivities;
}

2.3、ActivityStack

ActivityStack 是TaskRecord的一个分组，用于管理TaskRecord列表,列表中的TaskRecord可以重排顺序。

final class ActivityStack {
    /**
     * The back history of all previous (and possibly still
     * running) activities.  It contains #TaskRecord objects.
     */
    private ArrayList mTaskHistory = new ArrayList<>();
}

2.3.1 TaskRecord、ActivityStack关系。

通常情况下,一个App对应一个ActivityStack,ActivityStatck中会有一个TaskRecord列表,通常列表中仅有一个TaskRecord,维护Activity栈。

image

一个Activity启动时,归属的TaskRecord,通常是启动它的Activity 对应的TaskRecord。
如ActivtiyA启动ActivityB,那么ActivityB会被保存在ActivityA所属的TaskRecord中。

image

当一个Activity的launchmode 设置了SingleIntance,那么它启动的时候就会新建一个TaskRecord,这时ActvityStack中就会存在多个TaskRecord 栈结构。

image

当设置了Intent.FLAG_ACTIVITY_NEW_TASK和taskAffinity时,可能会出现多个app共享同一个ActivityStack的情况。

taskAffinity 可以指定Activity需要宿主TaskRecord的名字,当ActivityManagerService发现启动了一个带有 FLAG_ACTIVITY_NEW_TASK 标签的 Activity 时,会先去查找当前AMS中是否存在activity需要的ActivityStack和TaskRecord，如果存在则直接将ActivityRecord添加到对应ActivityStack的TaskRecord中去,否则会先新建一个TaskRecord,然后将ActvityRecord添加到新建的TaskRecord中。

adb shell dumpsys activity 查看activity栈的请款

ACTIVITY MANAGER ACTIVITIES (dumpsys activity activities)
Display #0 (activities from top to bottom):
  Stack #1:

      TaskRecord{4212758 #173 A=com.sogou.iot.testtouch1 U=0 StackId=1 sz=2}
      Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.sogou.iot.testtouch1/.MainActivity }
        Hist #1: ActivityRecord{4c91dda u0 com.sogou.iot.testtouch1/.SecondActivity t173}
          Intent { cmp=com.sogou.iot.testtouch1/.SecondActivity }
          ProcessRecord{3fd8bbc 23189:com.sogou.iot.testtouch1/u0a79}
        Hist #0: ActivityRecord{93a3d53 u0 com.sogou.iot.testtouch1/.MainActivity t173}
          Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.sogou.iot.testtouch1/.MainActivity bnds=[433,77][644,372] }
          ProcessRecord{3fd8bbc 23189:com.sogou.iot.testtouch1/u0a79}

    Running activities (most recent first):
      TaskRecord{4212758 #173 A=com.sogou.iot.testtouch1 U=0 StackId=1 sz=2}
        Run #1: ActivityRecord{4c91dda u0 com.sogou.iot.testtouch1/.SecondActivity t173}
        Run #0: ActivityRecord{93a3d53 u0 com.sogou.iot.testtouch1/.MainActivity t173}

    mResumedActivity: ActivityRecord{4c91dda u0 com.sogou.iot.testtouch1/.SecondActivity t173}

  Stack #0:

      TaskRecord{db2272c #1 A=com.huawei.android.launcher U=0 StackId=0 sz=1}
      Intent { act=android.intent.action.MAIN cat=[android.intent.category.HOME] flg=0x10000300 cmp=com.huawei.android.launcher/.unihome.UniHomeLauncher }
        Hist #0: ActivityRecord{60dec4e u0 com.huawei.android.launcher/.unihome.UniHomeLauncher t1}
          Intent { act=android.intent.action.MAIN cat=[android.intent.category.HOME] flg=0x10000300 cmp=com.huawei.android.launcher/.unihome.UniHomeLauncher }
          ProcessRecord{c03fa2 1781:com.huawei.android.launcher/u0a50}

    Running activities (most recent first):
      TaskRecord{db2272c #1 A=com.huawei.android.launcher U=0 StackId=0 sz=1}
        Run #0: ActivityRecord{60dec4e u0 com.huawei.android.launcher/.unihome.UniHomeLauncher t1}

Stack #0: 代表一个ActivityStack, id = 0 说明是Launcher相关的ActivitStack。
Stack #1: ActivityStack id = 1 ,代表常规App的ActvityStack,其中存在一个TaskRecord栈,栈中有两个ActivityRecord (MainActivity和SecondActivity),SecondeActivity在栈顶,处于Resume状态

2.4、ActivityStackSupervisor

ActivityStackSupervisor是ActivityStack的管理者。
内部管理了mHomeStack、mFocusedStack和mLastFocusedStack三个ActivityStack。
其中，mHomeStack管理的是Launcher相关的Activity栈，stackId为0；
mFocusedStack管理的是当前显示在前台Activity的Activity栈；
mLastFocusedStack管理的是上一次显示在前台Activity的Activity栈。

image

ActivityDisplay表示一个屏幕，Android支持三种屏幕：主屏幕，外接屏幕（HDMI等），虚拟屏幕（投屏）。一般情况下，即只有主屏幕时，ActivityStackSupervisor与ActivityDisplay都是系统唯一；

ActivityDisplay是ActivityStackSupervisor的内部类，它相当于一个工具类，封装了移除和添加ActivityStack的方法。

2.5 ActivityThread:

ActivityThread 运行在UI线程（主线程），App的真正入口。

2.6 ApplicationThread

ApplicationThread是一个Binder类，即可实现跨进程通信。主要用于接受从AMS传递过来的IPC消息，继而做相应处理。

 private class ApplicationThread extends IApplicationThread.Stub{
     
 }

2.7 IActivityManager

继承与IInterface接口，用于app进程向ActivityManagerService 单向IPC通信

2.8、Instrumentation

仪表盘，负责调用Activity和Application生命周期，测试用到这个类比较多。

三、具体的启动过程

3.1、流程概述

Launcher：Launcher通知AMS要启动activity

startActivitySafely->startActivity->Instrumentation.execStartActivity()(AMP.startActivity)->AMS.startActivity

ActivitMapagerService:PackageManagerService的resoveIntent验证要启动activity是否匹配。

如果匹配，通过ApplicationThread发消息给Launcher所在的主线程，暂停当前Activity(Launcher);
暂停完，在该activity还不可见时，通知AMS，根据要启动的Activity配置ActivityStack。然后判断要启动的Activity进程是否存在?
- 存在：发送消息LAUNCH_ACTIVITY给需要启动的Activity主线程，执行handleLaunchActivity
- 不存在：通过socket向zygote请求创建进程。进程启动后，ActivityThread.attach

判断Application是否存在，若不存在，通过LoadApk.makeApplication创建一个。在主线程中通过thread.attach方法来关联ApplicationThread。
在通过ActivityStackSupervisor来获取当前需要显示的ActivityStack。
继续通过ApplicationThread来发送消息给主线程的Handler来启动Activity（handleLaunchActivity）
handleLauchActivity：调用了performLauchActivity，里边Instrumentation生成了新的activity对象，继续调用activity生命周期。

3.2、流程跟踪

阶段一:Launcher通知AMS要启动新的Activity（在Launcher所在的进程执行）

Activity.startActivity
Activity.startActivityForResult
Instrumentation.execStartActivity //交由Instrumentation代为发起请求
ActivityManager.getService().startActivity //通过IActivityManagerSingleton.get()得到一个AMP代理对象
ActivityManagerService.startActivity()

阶段二:AMS先校验一下Activity的正确性，如果正确的话，会暂存一下Activity的信息。然后AMS会通知Launcher程序pause Activity（在AMS所在进程执行）

ActivityManagerService.startActivity
ActivityManagerService.startActivityAsUser
ActivityStackSupervisor.startActivityMayWait
ActivityStarter.startActivityUnchecked
ActivityStarter.startActivity
ActivityStarter.startActivityUnchecked
ActivityStack.startActivityLocked
ActivityStackSupervisor.resumeFocusedStackTopActivityLocked
ActivityStack.resumeTopActivityUncheckedLocked
ActivityStack.resumeTopActivityInnerLocked

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options){
     if (mResumedActivity != null) {
            if (DEBUG_STATES) Slog.d(TAG_STATES,
                    "resumeTopActivityLocked: Pausing " + mResumedActivity);
            pausing |= startPausingLocked(userLeaving, false, next, false);
        }
}

ActivityStack.startPausingLocked

 if (prev.app != null && prev.app.thread != null) {
   
    mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken,
    PauseActivityItem.obtain(prev.finishing, userLeaving,
                                prev.configChangeFlags, pauseImmediately)
                                );
}

PauseActivityItem 为暂停Activity的一个ClientTransactionItem 事务,AMS对Activity的操作都封装成了事务来完成。

public class PauseActivityItem extends ActivityLifecycleItem {

    private static final String TAG = "PauseActivityItem";

    private boolean mFinished;
    private boolean mUserLeaving;
    private int mConfigChanges;
    private boolean mDontReport;

    @Override
    public void execute(ClientTransactionHandler client, IBinder token,
      
        client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,
                "PAUSE_ACTIVITY_ITEM");
     
    }
}

public abstract class ActivityLifecycleItem extends ClientTransactionItem {

    @Retention(RetentionPolicy.SOURCE)
    public @interface LifecycleState{}
    public static final int UNDEFINED = -1;
    public static final int PRE_ON_CREATE = 0;
    public static final int ON_CREATE = 1;
    public static final int ON_START = 2;
    public static final int ON_RESUME = 3;
    public static final int ON_PAUSE = 4;
    public static final int ON_STOP = 5;
    public static final int ON_DESTROY = 6;
    public static final int ON_RESTART = 7;


}

public class ClientTransaction implements Parcelable, ObjectPoolItem {
       /** Target client. */
    private IApplicationThread mClient;

}

 public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }

mService.getLifecycleManager().scheduleTransaction,最终调用了IApplciationThread.scheduleTransaction()

此时完成 ActivityManagerService->ApplicationThread发消息，暂停Activity的过程。

阶段三: pause Launcher的Activity，并通知AMS已经paused（在Launcher所在进程执行）

上文知ActivityManagerService向ApplicationThread发送了一个PauseActivity的Transaction事务,相应的调用

ApplicationThread.scheduleTransaction()
ActivityThread.scheduleTransaction()
ActivityThread 发送H.EXECUTE_TRANSACTION
ActivityThread.H.handleMessage
ActivityThread.handlePauseActivity
IActivityManager.activityPaused

ApplicationThread的scheduleTransaction()方法，最终调用了ActivityThread的父类ClientTransactionHandler中的方法，发送了一个H.EXECUTE_TRANSACTION消息到主线程Handler

public abstract class ClientTransactionHandler {

    // Schedule phase related logic and handlers.

    /** Prepare and schedule transaction for execution. */
    void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
    }

handleMessage 处理EXECUTE_TRANSACTION消息时会调用TransactionExecutor.execuate()

 public void handleMessage(Message msg) {
  case EXECUTE_TRANSACTION:
                    final ClientTransaction transaction = (ClientTransaction) msg.obj;
                    mTransactionExecutor.execute(transaction);
                    break;
    }
    
    public class TransactionExecutor {
     public void execute(ClientTransaction transaction) {
      
    
            executeCallbacks(transaction);
    
            executeLifecycleState(transaction);
 
        }
        
    private void executeLifecycleState(ClientTransaction transaction) {
        final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();

     
        lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
        lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
    }
}

最终会调用ActivityThread的handlePauseActivity()方法

阶段四:检查activity所在进程是否存在，如果存在，就直接通知这个进程，在该进程中启动Activity；不存在的话，会调用Process.start创建一个新进程（执行在AMS进程）

ActivityManagerService.activityPaused

 @Override
    public final void activityPaused(IBinder token) {
        final long origId = Binder.clearCallingIdentity();
        synchronized(this) {
            ActivityStack stack = ActivityRecord.getStackLocked(token);
            if (stack != null) {
                stack.activityPausedLocked(token, false);
            }
        }
        Binder.restoreCallingIdentity(origId);
    }

ActivityStack.activityPausedLocked

 final void activityPausedLocked(IBinder token, boolean timeout) {
   completePauseLocked(true /* resumeNext */, null /* resumingActivity */);
 }

ActivityStack.completePauseLocked
ActivityStackSupervisor.resumeFocusedStackTopActivityLocked
ActivityStack.resumeTopActivityUncheckedLocked
ActivityStack.resumeTopActivityInnerLocked
ActivityStack.startSpecificActivityLocked

ActivityStack.startSpecificActivityLocked

经过一系列调用，最终代码又回到了 ActivityStackSupervisor 中的 startSpecificActivityLocked 方法。


void startSpecificActivityLocked(ActivityRecord r,
        boolean andResume, boolean checkConfig) {

     //注释一:根据进程名和uuid判断Activity所属的进程是否创建   
    // Is this activity's application already running?
    ProcessRecord app = mService.getProcessRecordLocked(r.processName,
            r.info.applicationInfo.uid, true);

    if (app != null && app.thread != null) {
        try {
            if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
                    || !"android".equals(r.info.packageName)) {
                // Don't add this if it is a platform component that is marked
                // to run in multiple processes, because this is actually
                // part of the framework so doesn't make sense to track as a
                // separate apk in the process.
                app.addPackage(r.info.packageName, r.info.applicationInfo.longVersionCode,
                        mService.mProcessStats);
            }
            //注释二
            realStartActivityLocked(r, app, andResume, checkConfig);
            return;
        } catch (RemoteException e) {
            Slog.w(TAG, "Exception when starting activity "
                    + r.intent.getComponent().flattenToShortString(), e);
        }

        // If a dead object exception was thrown -- fall through to
        // restart the application.
    }

    //注释三 调用ActivityManagerService 启动activity所在进程
    mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
            "activity", r.intent.getComponent(), false, false, true);
}

注释一根据进程名和 Application 的 uid，来判断目标进程是否已经创建，如果没有则代表进程未创建。
注释二如果acitivity所在的进程已经存在,则尝试启动Activity
注释三如果activity所在的进程不存在,则尝试调用ActivityManagerService来启动进程。

首次启动App,app进程为空,会尝试创建app进程,不会执行realStartActivityLocked

ActivityManagerService.startProcessLocked
Process.start //在这里创建了新进程，新的进程会导入ActivityThread类，并执行它的main函数

阶段五:进程创建后,执行ActivityThread.main()入口函数,

创建ActivityThread实例，执行ActivityThread.attach()，创建Application。IPC向ActivityManagerService发送 attachApplication消息,之后进入Loop循环。（执行在新创建的app进程）

ActivityThread.main
ActivityThread.attach(false) //声明不是系统进程
ActivityManagerProxy.attachApplication

阶段六:处理新的应用进程发出的创建进程完成的通信请求,并通知新应用程序进程启动目标Activity组件（执行在AMS进程）

ActivityManagerService.attachApplication //AMS绑定本地ApplicationThread对象，后续通过ApplicationThread（Binder）对象进行通信
ActivityManagerService.attachApplicationLocked

  private final boolean attachApplicationLocked(IApplicationThread thread,
            int pid, int callingUid, long startSeq) {
                  // See if the top visible activity is waiting to run in this process...
        if (normalMode) {
            try {
                if (mStackSupervisor.attachApplicationLocked(app)) {
                    didSomething = true;
                }
            } catch (Exception e) {
                Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
                badApp = true;
            }
        }
}

ActivityStackSupervisor.attachApplicationLocked

boolean attachApplicationLocked(ProcessRecord app){
    
   realStartActivityLocked(activity, app,top == activity /* andResume */, true /* checkConfig */)) {
                         
}

ActivityStackSupervisor.realStartActivityLocked //真正要启动Activity了！

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
                
                // Create activity launch transaction.
                final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
                        r.appToken);
                clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                        System.identityHashCode(r), r.info,
                        // TODO: Have this take the merged configuration instead of separate global
                        // and override configs.
                        mergedConfiguration.getGlobalConfiguration(),
                        mergedConfiguration.getOverrideConfiguration(), r.compat,
                        r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
                        r.persistentState, results, newIntents, mService.isNextTransitionForward(),
                        profilerInfo));

                // Set desired final state.
                final ActivityLifecycleItem lifecycleItem;
                if (andResume) {
                    lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
                } else {
                    lifecycleItem = PauseActivityItem.obtain();
                }
                clientTransaction.setLifecycleStateRequest(lifecycleItem);

                // Schedule transaction.
                mService.getLifecycleManager().scheduleTransaction(clientTransaction);
            }

realStartActivityLocked 创建了一个LaunchActivityItem的事务,通过ApplicationThread IPC发送给了新创建的app进程。

ActivityThread.handleLaunchActivity
ActivityThread.performLaunchActivity

 /**  Core implementation of activity launch. */
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    ActivityInfo aInfo = r.activityInfo;

    //（1）为Activity创建Context
    ContextImpl appContext = createBaseContextForActivity(r);
    Activity activity = null;
    
  
    //(2) 通过Instrumentation 创建Activity实例
    activity = mInstrumentation.newActivity( cl, component.getClassName(), r.intent);
    

        //获取Applciation实例 
    Application app = r.packageInfo.makeApplication(false, mInstrumentation);

    if (activity != null) {
        //(3)调用activity.attach()
        activity.attach(appContext, this, getInstrumentation(), r.token,
                r.ident, app, r.intent, r.activityInfo, title, r.parent,
                r.embeddedID, r.lastNonConfigurationInstances, config,
                r.referrer, r.voiceInteractor, window, r.configCallback);

        if (customIntent != null) {
            activity.mIntent = customIntent;
        }
      
        int theme = r.activityInfo.getThemeResource();
        if (theme != 0) {
            activity.setTheme(theme);
        }

        //(4) 调用Instrumentation.callActivityOnCreate() 触发Activity生命周期
        if (r.isPersistable()) {
            mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
        } else {
            mInstrumentation.callActivityOnCreate(activity, r.state);
        }
         
    return activity;
}

至此Activity已经被启动起来了

四、参考文章

ActivityRecord

应用内一个Activity启动另一个Activity
应用内StartActivity过程

Launcher点击图标启动应用

Activity启动过程分析(android-28)

一、Activity启动前的进程关系

1.1、什么是init进程

1.2、Zygote进程

1.3、为什么是Zygote来孵化进程，而不是新建进程呢？

二、Activity启动涉及到的一些类:

2.1、ActivityRecord

2.2、TaskRecord

2.3、ActivityStack

2.3.1 TaskRecord、ActivityStack关系。

2.4、ActivityStackSupervisor

2.5 ActivityThread:

2.6 ApplicationThread

2.7 IActivityManager

2.8、Instrumentation

三、具体的启动过程

3.1、流程概述

3.2、流程跟踪

阶段一:Launcher通知AMS要启动新的Activity（在Launcher所在的进程执行）

阶段二:AMS先校验一下Activity的正确性，如果正确的话，会暂存一下Activity的信息。然后AMS会通知Launcher程序pause Activity（在AMS所在进程执行）

阶段三: pause Launcher的Activity，并通知AMS已经paused（在Launcher所在进程执行）

阶段四:检查activity所在进程是否存在，如果存在，就直接通知这个进程，在该进程中启动Activity；不存在的话，会调用Process.start创建一个新进程（执行在AMS进程）

阶段五:进程创建后,执行ActivityThread.main()入口函数,

阶段六:处理新的应用进程发出的创建进程完成的通信请求,并通知新应用程序进程启动目标Activity组件（执行在AMS进程）

四、参考文章

你可能感兴趣的:(Activity启动过程分析(android-28))