Android系统核心服务协作：从点击图标到应用显示的完整链路

串联所有核心知识点，深入剖析从Launcher点击图标到应用界面显示的完整流程，理解AMS、WMS、Zygote、Binder等核心服务的协作机制。

引言

经过前26篇的深入学习，我们已经掌握了Android系统的各个核心子系统：

• Binder机制 - 跨进程通信基础
• Zygote与进程孵化 - 应用进程创建
• AMS - Activity和进程生命周期管理
• PMS - 应用包安装与管理
• WMS - 窗口与显示管理
• InputManagerService - 输入事件分发
• PowerManagerService - 电源管理与Doze模式
• NotificationManagerService - 通知管理
• JobScheduler - 任务调度
• ContentProvider - 跨应用数据共享

今天，在这个系列的终篇中，我们将把这些零散的知识点串联起来，完整追踪从用户点击Launcher图标到应用界面显示并响应用户输入的全流程，看看这些核心服务如何协作完成一次完美的应用启动。

这就像是一场精心编排的交响乐：Launcher起奏，AMS指挥，Zygote孕育新生，WMS布置舞台，SurfaceFlinger点亮灯光，最终呈现出一个完整的应用界面。

一、完整流程概览

1.1 核心阶段划分

应用启动可以分为7个核心阶段：

用户交互 → AMS处理 → Zygote孵化 → 应用初始化 → Activity启动 → 窗口创建 → 界面显示
   ↓          ↓          ↓           ↓            ↓          ↓          ↓
Launcher    Intent    Socket     ActivityThread  onCreate   addWindow   合成显示
  onClick   解析      fork()      attachApp      onResume   Surface     触摸事件

1.2 涉及的核心服务

服务	职责	关键方法
Launcher	桌面应用	onClick() → startActivity()
ActivityManagerService	Activity管理	startActivity() / startProcessLocked()
PackageManagerService	包信息查询	resolveIntent() / getActivityInfo()
Zygote	进程孵化	fork() 系统调用
ApplicationThread	应用Binder代理	scheduleLaunchActivity()
ActivityThread	应用主线程	handleLaunchActivity()
WindowManagerService	窗口管理	addWindow() / relayoutWindow()
SurfaceFlinger	图形合成	createSurface() / 图层合成
InputManagerService	输入分发	dispatchKey() / dispatchTouch()

1.3 通信方式

• Binder IPC: Launcher ↔ AMS, AMS ↔ WMS, App ↔ AMS
• Socket: AMS ↔ Zygote (LocalSocket通信)
• 共享内存: App ↔ SurfaceFlinger (GraphicBuffer)
• Handler消息: ActivityThread内部消息循环

二、阶段1：Launcher点击图标

2.1 Launcher界面点击

// packages/apps/Launcher3/src/com/android/launcher3/Launcher.java
public class Launcher extends StatefulActivity<LauncherState> {
    // 用户点击应用图标
    protected void onClickAppShortcut(View v, ItemInfo item) {
        // 1. 获取Intent
        Intent intent = item.getIntent();

        // 2. 设置启动标志
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

        // 3. 启动Activity
        boolean success = startActivitySafely(v, intent, item);

        if (success && v instanceof BubbleTextView) {
            // 显示启动动画
            mAppTransitionManager.registerRemoteAnimations();
        }
    }

    public boolean startActivitySafely(
            View v,
            Intent intent,
            ItemInfo item) {
        // 设置启动选项（动画、窗口大小等）
        ActivityOptions opts = makeLaunchOptions(v);

        try {
            // 调用Context.startActivity()
            startActivity(intent, opts.toBundle());
            return true;
        } catch (ActivityNotFoundException e) {
            Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
            return false;
        } catch (SecurityException e) {
            Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
            return false;
        }
    }
}

Intent内容：

Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_LAUNCHER);
intent.setComponent(new ComponentName("com.example.app", "com.example.app.MainActivity"));
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

2.2 Context.startActivity()

// frameworks/base/core/java/android/app/Activity.java
@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
    if (options != null) {
        startActivityForResult(intent, -1, options);
    } else {
        startActivityForResult(intent, -1);
    }
}

public void startActivityForResult(
        Intent intent,
        int requestCode,
        @Nullable Bundle options) {
    // 通过Instrumentation启动
    Instrumentation.ActivityResult ar =
        mInstrumentation.execStartActivity(
            this,           // who
            mMainThread.getApplicationThread(),  // contextThread
            mToken,         // token
            this,           // target
            intent,         // intent
            requestCode,    // requestCode
            options         // options
        );
}

2.3 Instrumentation → AMS

// frameworks/base/core/java/android/app/Instrumentation.java
public ActivityResult execStartActivity(
        Context who,
        IBinder contextThread,
        IBinder token,
        Activity target,
        Intent intent,
        int requestCode,
        Bundle options) {
    // 获取AMS的Binder代理
    IActivityTaskManager service = ActivityTaskManager.getService();

    try {
        // Binder跨进程调用AMS
        int result = service.startActivity(
            who.getBasePackageName(),  // caller
            intent,                    // intent
            intent.resolveTypeIfNeeded(who.getContentResolver()),
            token,                     // resultTo
            target != null ? target.mEmbeddedID : null,
            requestCode,               // requestCode
            0,                         // startFlags
            null,                      // profilerInfo
            options                    // options
        );

        // 检查结果
        checkStartActivityResult(result, intent);

    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }

    return null;
}

关键点：

• Launcher通过Binder IPC调用AMS的startActivity()
• 传递Intent、启动选项、调用者信息
• AMS在system_server进程执行

三、阶段2：AMS处理启动请求

3.1 AMS.startActivity()

// frameworks/base/services/core/java/com/android/server/am/ActivityTaskManagerService.java
@Override
public int startActivity(
        IApplicationThread caller,
        String callingPackage,
        Intent intent,
        String resolvedType,
        IBinder resultTo,
        String resultWho,
        int requestCode,
        int startFlags,
        ProfilerInfo profilerInfo,
        Bundle bOptions) {
    // 1. 权限检查
    enforceNotIsolatedCaller("startActivity");

    // 2. 用户ID检查
    int userId = mUserController.handleIncomingUser(
        Binder.getCallingPid(),
        Binder.getCallingUid(),
        UserHandle.USER_CURRENT,
        "startActivity"
    );

    // 3. 委托给ActivityStarter处理
    return mActivityStartController.obtainStarter(intent, "startActivity")
        .setCaller(caller)
        .setCallingPackage(callingPackage)
        .setResolvedType(resolvedType)
        .setResultTo(resultTo)
        .setRequestCode(requestCode)
        .setStartFlags(startFlags)
        .setActivityOptions(bOptions)
        .setUserId(userId)
        .execute();  // 执行启动
}

3.2 ActivityStarter.execute()

// frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
int execute() {
    try {
        // 1. 解析Intent
        if (mRequest.intent != null) {
            resolveActivity(mRequest);
        }

        // 2. 执行启动
        int res = executeRequest(mRequest);

        return res;
    } finally {
        onExecutionComplete();
    }
}

private void resolveActivity(Request request) {
    // 通过PMS解析Intent
    ResolveInfo rInfo = mSupervisor.resolveIntent(
        request.intent,
        request.resolvedType,
        request.userId
    );

    if (rInfo == null) {
        throw new ActivityNotFoundException(
            "Unable to find explicit activity class");
    }

    // 获取ActivityInfo
    ActivityInfo aInfo = rInfo.activityInfo;
    request.activityInfo = aInfo;
}

private int executeRequest(Request request) {
    // 1. 创建ActivityRecord
    ActivityRecord r = new ActivityRecord(
        mService,
        request.activityInfo,
        request.intent,
        request.resultTo,
        request.userId
    );

    // 2. 启动Activity
    return startActivityUnchecked(r, ...);
}

3.3 启动或创建进程

private int startActivityUnchecked(ActivityRecord r, ...) {
    // 1. Task栈管理
    TaskRecord taskTop = mTargetStack.topTask();
    if (taskTop == null || !taskTop.isSameIntentFilter(r)) {
        // 创建新Task
        mTargetStack.createTask(r, ...);
    }

    // 2. 检查进程状态
    ProcessRecord app = mService.getProcessRecordLocked(
        r.processName,
        r.info.applicationInfo.uid
    );

    if (app != null && app.thread != null) {
        // 进程已存在，直接启动Activity
        realStartActivityLocked(r, app, ...);
    } else {
        // 进程不存在，先创建进程
        mService.startProcessLocked(
            r.processName,
            r.info.applicationInfo,
            "activity",
            r.intent.getComponent()
        );
    }

    return START_SUCCESS;
}

3.4 PMS查询ActivityInfo

// frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java
@Override
public ResolveInfo resolveIntent(
        Intent intent,
        String resolvedType,
        int flags,
        int userId) {
    // 1. 查询组件
    List<ResolveInfo> query = queryIntentActivitiesInternal(
        intent,
        resolvedType,
        flags,
        userId
    );

    if (query == null || query.size() == 0) {
        return null;
    }

    // 2. 选择最佳匹配
    return chooseBestActivity(query, intent);
}

private List<ResolveInfo> queryIntentActivitiesInternal(...) {
    ComponentName comp = intent.getComponent();

    if (comp != null) {
        // 显式Intent，直接查找
        ActivityInfo ai = getActivityInfo(comp, flags, userId);
        if (ai != null) {
            ResolveInfo ri = new ResolveInfo();
            ri.activityInfo = ai;
            return Collections.singletonList(ri);
        }
    }

    // 隐式Intent，匹配IntentFilter
    return mComponentResolver.queryActivities(intent, resolvedType, flags, userId);
}

四、阶段3：Zygote孵化新进程

4.1 AMS请求Zygote

// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
boolean startProcessLocked(
        String processName,
        ApplicationInfo info,
        String hostingType,
        ComponentName hostingName) {
    return startProcessLocked(
        processName,
        info,
        hostingType,
        hostingName,
        null /* abiOverride */
    );
}

boolean startProcessLocked(...) {
    synchronized (this) {
        // 1. 创建ProcessRecord
        ProcessRecord app = new ProcessRecord(
            mService,
            info,
            processName,
            uid
        );

        // 2. 请求Zygote fork进程
        final String entryPoint = "android.app.ActivityThread";
        return startProcess(app, entryPoint, ...);
    }
}

private boolean startProcess(ProcessRecord app, String entryPoint, ...) {
    try {
        // 通过Process.start()请求Zygote
        final Process.ProcessStartResult startResult = Process.start(
            entryPoint,                    // android.app.ActivityThread
            app.processName,               // 进程名
            uid,                           // UID
            gid,                           // GID
            gids,                          // 附加GID
            runtimeFlags,                  // 运行标志
            mountExternal,                 // 外部存储挂载模式
            app.info.targetSdkVersion,     // 目标SDK版本
            seInfo,                        // SELinux信息
            abi,                           // ABI
            instructionSet,                // 指令集
            app.info.dataDir,              // 数据目录
            invokeWith,                    // 调试器
            app.info.packageName,          // 包名
            zygoteArgs                     // Zygote参数
        );

        // 记录PID
        app.pid = startResult.pid;
        app.usingWrapper = startResult.usingWrapper;

        return true;
    } catch (RuntimeException e) {
        Log.e(TAG, "Failure starting process " + app.processName, e);
        return false;
    }
}

4.2 Zygote Socket通信

// frameworks/base/core/java/android/os/Process.java
public static ProcessStartResult start(
        final String processClass,
        final String niceName,
        int uid, int gid, int[] gids,
        int runtimeFlags,
        int mountExternal,
        int targetSdkVersion,
        String seInfo,
        String abi,
        String instructionSet,
        String appDataDir,
        String invokeWith,
        String packageName,
        String[] zygoteArgs) {
    // 通过ZygoteProcess发送请求
    return ZYGOTE_PROCESS.start(
        processClass,
        niceName,
        uid, gid, gids,
        runtimeFlags,
        mountExternal,
        targetSdkVersion,
        seInfo,
        abi,
        instructionSet,
        appDataDir,
        invokeWith,
        packageName,
        zygoteArgs
    );
}

// frameworks/base/core/java/android/os/ZygoteProcess.java
public final Process.ProcessStartResult start(...) {
    try {
        // 连接Zygote Socket
        return startViaZygote(
            processClass,
            niceName,
            uid, gid, gids,
            runtimeFlags,
            mountExternal,
            targetSdkVersion,
            seInfo,
            abi,
            instructionSet,
            appDataDir,
            invokeWith,
            packageName,
            zygoteArgs
        );
    } catch (ZygoteStartFailedEx ex) {
        throw new RuntimeException(
            "Starting VM process through Zygote failed", ex);
    }
}

private Process.ProcessStartResult startViaZygote(...) {
    // 1. 构建参数列表
    ArrayList<String> argsForZygote = new ArrayList<>();
    argsForZygote.add("--runtime-args");
    argsForZygote.add("--setuid=" + uid);
    argsForZygote.add("--setgid=" + gid);
    argsForZygote.add("--target-sdk-version=" + targetSdkVersion);
    argsForZygote.add("--nice-name=" + niceName);
    argsForZygote.add(processClass);  // android.app.ActivityThread

    // 2. 通过Socket发送请求
    synchronized (mLock) {
        return zygoteSendArgsAndGetResult(
            openZygoteSocketIfNeeded(abi),
            argsForZygote
        );
    }
}

private Process.ProcessStartResult zygoteSendArgsAndGetResult(
        ZygoteState zygoteState,
        ArrayList<String> args) {
    // 1. 写入参数到Socket
    final BufferedWriter writer = zygoteState.writer;
    final DataInputStream inputStream = zygoteState.inputStream;

    writer.write(Integer.toString(args.size()));
    writer.newLine();

    for (String arg : args) {
        writer.write(arg);
        writer.newLine();
    }
    writer.flush();

    // 2. 读取Zygote返回的PID
    Process.ProcessStartResult result = new Process.ProcessStartResult();
    result.pid = inputStream.readInt();
    result.usingWrapper = inputStream.readBoolean();

    if (result.pid < 0) {
        throw new ZygoteStartFailedEx("fork() failed");
    }

    return result;
}

4.3 Zygote fork进程

// frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java
Runnable processOneCommand(ZygoteServer zygoteServer) {
    // 1. 读取参数
    String args[] = readArgumentList();
    Arguments parsedArgs = new Arguments(args);

    // 2. fork进程
    pid = Zygote.forkAndSpecialize(
        parsedArgs.uid,
        parsedArgs.gid,
        parsedArgs.gids,
        parsedArgs.runtimeFlags,
        rlimits,
        parsedArgs.mountExternal,
        parsedArgs.seInfo,
        parsedArgs.niceName,
        fdsToClose,
        fdsToIgnore,
        parsedArgs.startChildZygote,
        parsedArgs.instructionSet,
        parsedArgs.appDataDir,
        parsedArgs.packageName,
        parsedArgs.zygoteArgs
    );

    if (pid == 0) {
        // 子进程：新应用进程
        zygoteServer.closeServerSocket();

        // 返回Runnable，在子进程中执行
        return handleChildProc(parsedArgs, ...);
    } else {
        // 父进程：Zygote
        return null;
    }
}

private Runnable handleChildProc(Arguments parsedArgs, ...) {
    // 关闭从Zygote继承的Socket
    closeSocket();

    // 执行ActivityThread.main()
    return ZygoteInit.zygoteInit(
        parsedArgs.targetSdkVersion,
        parsedArgs.remainingArgs,
        null  // classLoader
    );
}

// frameworks/base/core/jni/com_android_internal_os_Zygote.cpp
static jint com_android_internal_os_Zygote_nativeForkAndSpecialize(
        JNIEnv* env, jclass, ...) {
    // fork()系统调用
    pid_t pid = fork();

    if (pid == 0) {
        // 子进程
        // 1. 设置进程属性
        SetGids(env, javaGids);
        SetRLimits(env, javaRlimits);
        SetCapabilities(env, permittedCapabilities, effectiveCapabilities);
        SetSchedulerPolicy(env);

        // 2. SELinux上下文切换
        if (seInfo != NULL) {
            rc = selinux_android_setcontext(uid, is_system_server, seInfo, nice_name);
        }

        // 3. 挂载外部存储
        if (mount_external != MOUNT_EXTERNAL_NONE) {
            SpecializeCommon(env, uid, gid, ...);
        }

        // 4. 设置进程名
        SetThreadName(nice_name);

    } else if (pid > 0) {
        // 父进程：Zygote
        // 记录子进程信息
    }

    return pid;
}

关键点：

• AMS通过LocalSocket与Zygote通信（/dev/socket/zygote）
• Zygote调用fork()系统调用创建子进程
• 子进程继承Zygote的地址空间（Copy-on-Write）
• 新进程执行android.app.ActivityThread.main()

五、阶段4：应用进程初始化

5.1 ActivityThread.main()

// frameworks/base/core/java/android/app/ActivityThread.java
public static void main(String[] args) {
    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");

    // 1. 准备主线程Looper
    Looper.prepareMainLooper();

    // 2. 创建ActivityThread实例
    ActivityThread thread = new ActivityThread();
    thread.attach(false, startSeq);  // 非系统进程

    // 3. 获取主线程Handler
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }

    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

    // 4. 启动消息循环
    Looper.loop();

    throw new RuntimeException("Main thread loop unexpectedly exited");
}

5.2 attach到AMS

private void attach(boolean system, long startSeq) {
    sCurrentActivityThread = this;
    mSystemThread = system;

    if (!system) {
        // 应用进程
        // 1. 设置进程名
        android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
                                                UserHandle.myUserId());

        // 2. 设置HTTP User-Agent
        RuntimeInit.setApplicationObject(mAppThread.asBinder());

        // 3. 获取AMS代理
        final IActivityManager mgr = ActivityManager.getService();

        try {
            // 4. Binder调用：attach到AMS
            mgr.attachApplication(mAppThread, startSeq);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    } else {
        // 系统进程（system_server）
        // ...
    }
}

5.3 AMS.attachApplication()

// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
@Override
public final void attachApplication(IApplicationThread thread, long startSeq) {
    synchronized (this) {
        // 1. 查找ProcessRecord
        int callingPid = Binder.getCallingPid();
        ProcessRecord app = mPidsSelfLocked.get(callingPid);

        if (app == null) {
            throw new SecurityException("Unknown process pid=" + callingPid);
        }

        // 2. 绑定ApplicationThread
        app.makeActive(thread, mProcessStats);

        // 3. 初始化应用
        attachApplicationLocked(thread, callingPid, startSeq);
    }
}

private boolean attachApplicationLocked(
        IApplicationThread thread,
        int pid,
        long startSeq) {
    ProcessRecord app = mPidsSelfLocked.get(pid);

    // 1. 构建应用信息
    ApplicationInfo appInfo = app.info;

    // 2. 通知应用进程绑定Application
    thread.bindApplication(
        processName,
        appInfo,
        providers,                // ContentProvider列表
        app.instrumentationClass,
        profilerInfo,
        app.instrumentationArguments,
        app.instrumentationWatcher,
        app.instrumentationUiAutomationConnection,
        testMode,
        mBinderTransactionTrackingEnabled,
        enableTrackAllocation,
        isRestrictedBackupMode || !normalMode,
        app.persistent,
        new Configuration(mConfiguration),
        app.compat,
        getCommonServicesLocked(app.isolated),
        mCoreSettingsObserver.getCoreSettingsLocked(),
        buildSerial,
        isAutofillCompatEnabled
    );

    // 3. 启动待启动的Activity
    if (mStackSupervisor.attachApplicationLocked(app)) {
        // Activity启动成功
    }

    return true;
}

5.4 bindApplication()

// frameworks/base/core/java/android/app/ActivityThread.java
public final void bindApplication(...) {
    // 1. 发送BIND_APPLICATION消息
    AppBindData data = new AppBindData();
    data.processName = processName;
    data.appInfo = appInfo;
    data.providers = providers;
    data.instrumentationName = instrumentationName;
    data.info = getPackageInfoNoCheck(appInfo);

    sendMessage(H.BIND_APPLICATION, data);
}

private void handleBindApplication(AppBindData data) {
    // 1. 创建LoadedApk
    data.info = getPackageInfoNoCheck(data.appInfo);

    // 2. 创建ContextImpl
    final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);

    // 3. 安装ContentProvider（在Application.onCreate之前！）
    if (!data.providers.isEmpty()) {
        installContentProviders(app, data.providers);
    }

    // 4. 创建Instrumentation
    if (data.instrumentationName != null) {
        InstrumentationInfo ii = getInstrumentationInfo(data.instrumentationName);
        mInstrumentation = (Instrumentation)
            ii.getClassLoader().loadClass(ii.name).newInstance();
        mInstrumentation.init(this, ...);
    } else {
        mInstrumentation = new Instrumentation();
        mInstrumentation.basicInit(this);
    }

    // 5. 创建Application
    Application app = data.info.makeApplication(false, mInstrumentation);
    mInitialApplication = app;

    // 6. 调用Application.onCreate()
    mInstrumentation.callApplicationOnCreate(app);
}

关键时序：

ActivityThread.main()
    ↓
attach(AMS)
    ↓
bindApplication()
    ↓
installContentProviders()  ← ContentProvider.onCreate()
    ↓
Application.onCreate()     ← 在这里初始化

六、阶段5：Activity启动

6.1 scheduleLaunchActivity()

// AMS通知应用启动Activity
@Override
public final void scheduleLaunchActivity(
        Intent intent,
        IBinder token,
        int ident,
        ActivityInfo info,
        Configuration curConfig,
        Configuration overrideConfig,
        ...) {
    // 1. 构建ActivityClientRecord
    ActivityClientRecord r = new ActivityClientRecord();
    r.token = token;
    r.ident = ident;
    r.intent = intent;
    r.activityInfo = info;
    r.state = null;

    // 2. 发送LAUNCH_ACTIVITY消息
    sendMessage(H.LAUNCH_ACTIVITY, r);
}

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    // 1. 性能追踪
    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");

    // 2. WindowManager准备
    WindowManagerGlobal.initialize();

    // 3. 执行启动
    Activity a = performLaunchActivity(r, customIntent);

    if (a != null) {
        // 4. Activity已创建，调用onResume
        handleResumeActivity(r.token, ...);
    } else {
        // 启动失败，通知AMS
        ActivityManager.getService().finishActivity(r.token, ...);
    }

    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
}

6.2 performLaunchActivity()

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    // 1. 获取ActivityInfo
    ActivityInfo aInfo = r.activityInfo;

    // 2. 创建Context
    ContextImpl appContext = createBaseContextForActivity(r);

    Activity activity = null;
    try {
        // 3. 通过反射创建Activity实例
        java.lang.ClassLoader cl = appContext.getClassLoader();
        activity = mInstrumentation.newActivity(
            cl,
            component.getClassName(),
            r.intent
        );

        // 4. 创建Application
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);

        if (activity != null) {
            // 5. attach Activity到Window
            activity.attach(
                appContext,
                this,              // ActivityThread
                mInstrumentation,
                r.token,           // IBinder token
                r.ident,
                app,               // Application
                r.intent,
                r.activityInfo,
                title,
                r.parent,
                r.embeddedID,
                r.lastNonConfigurationInstances,
                config,
                r.referrer,
                r.voiceInteractor,
                window,
                r.configCallback,
                r.assistToken
            );

            // 6. 调用Activity.onCreate()
            if (r.isPersistable()) {
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }

            // 7. 调用Activity.onStart()
            if (!r.activity.mFinished) {
                activity.performStart();
                r.stopped = false;
            }
        }

        r.paused = false;

        mActivities.put(r.token, r);

    } catch (Exception e) {
        if (!mInstrumentation.onException(activity, e)) {
            throw new RuntimeException(
                "Unable to start activity " + component, e);
        }
    }

    return activity;
}

6.3 Activity.attach()

// frameworks/base/core/java/android/app/Activity.java
final void attach(
        Context context,
        ActivityThread aThread,
        Instrumentation instr,
        IBinder token,
        int ident,
        Application application,
        Intent intent,
        ActivityInfo info,
        CharSequence title,
        Activity parent,
        String id,
        NonConfigurationInstances lastNonConfigurationInstances,
        Configuration config,
        String referrer,
        IVoiceInteractor voiceInteractor,
        Window window,
        ActivityConfigCallback activityConfigCallback,
        IBinder assistToken) {
    attachBaseContext(context);

    mFragments.attachHost(null);

    // 1. 创建PhoneWindow
    mWindow = new PhoneWindow(this, window, activityConfigCallback);
    mWindow.setWindowControllerCallback(this);
    mWindow.setCallback(this);
    mWindow.setOnWindowDismissedCallback(this);
    mWindow.getLayoutInflater().setPrivateFactory(this);

    // 2. 设置软键盘模式
    if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
        mWindow.setSoftInputMode(info.softInputMode);
    }

    // 3. 设置UIOptions
    if (info.uiOptions != 0) {
        mWindow.setUiOptions(info.uiOptions);
    }

    mUiThread = Thread.currentThread();

    mMainThread = aThread;
    mInstrumentation = instr;
    mToken = token;
    mApplication = application;
    mIntent = intent;
    mComponent = intent.getComponent();
    mActivityInfo = info;
    mTitle = title;
    mParent = parent;
    mEmbeddedID = id;

    // 4. 设置WindowManager
    mWindow.setWindowManager(
        (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
        mToken,
        mComponent.flattenToString(),
        (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0
    );

    if (mParent != null) {
        mWindow.setContainer(mParent.getWindow());
    }

    mWindowManager = mWindow.getWindowManager();
}

6.4 handleResumeActivity()

@Override
public void handleResumeActivity(IBinder token, ...) {
    // 1. 执行onResume()
    ActivityClientRecord r = performResumeActivity(token, ...);

    if (r != null) {
        final Activity a = r.activity;

        if (r.window == null && !a.mFinished && willBeVisible) {
            r.window = r.activity.getWindow();
            View decor = r.window.getDecorView();
            decor.setVisibility(View.INVISIBLE);
            ViewManager wm = a.getWindowManager();

            WindowManager.LayoutParams l = r.window.getAttributes();
            a.mDecor = decor;

            l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
            l.softInputMode |= forwardBit;

            if (a.mVisibleFromClient) {
                if (!a.mWindowAdded) {
                    a.mWindowAdded = true;
                    // 2. 添加窗口到WMS
                    wm.addView(decor, l);
                }
            }
        }

        // 3. 设置窗口可见
        if (!r.activity.mFinished && willBeVisible && r.activity.mDecor != null && !r.hideForNow) {
            r.activity.makeVisible();
        }

        // 4. 通知AMS Activity已Resume
        ActivityManager.getService().activityResumed(token);
    }
}

public ActivityClientRecord performResumeActivity(IBinder token, ...) {
    ActivityClientRecord r = mActivities.get(token);

    if (r != null && !r.activity.mFinished) {
        try {
            // 调用Activity.onResume()
            r.activity.performResume(r.startsNotResumed, reason);

            r.state = null;
            r.persistentState = null;
            r.paused = false;
            r.stopped = false;

        } catch (Exception e) {
            if (!mInstrumentation.onException(r.activity, e)) {
                throw new RuntimeException("Unable to resume activity", e);
            }
        }
    }

    return r;
}

Activity生命周期时序：

onCreate()
    ↓
onStart()
    ↓
onResume()
    ↓
addView(DecorView)  ← 关键：添加窗口
    ↓
makeVisible()       ← 窗口可见

七、阶段6：窗口创建与显示

7.1 WindowManager.addView()

// frameworks/base/core/java/android/view/WindowManagerImpl.java
@Override
public void addView(View view, ViewGroup.LayoutParams params) {
    applyDefaultToken(params);
    mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
}

// frameworks/base/core/java/android/view/WindowManagerGlobal.java
public void addView(View view, ViewGroup.LayoutParams params,
        Display display, Window parentWindow) {
    // 1. 参数检查
    if (view == null) {
        throw new IllegalArgumentException("view must not be null");
    }
    if (display == null) {
        throw new IllegalArgumentException("display must not be null");
    }
    if (!(params instanceof WindowManager.LayoutParams)) {
        throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
    }

    final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;

    synchronized (mLock) {
        // 2. 创建ViewRootImpl
        ViewRootImpl root = new ViewRootImpl(view.getContext(), display);

        view.setLayoutParams(wparams);

        mViews.add(view);
        mRoots.add(root);
        mParams.add(wparams);

        try {
            // 3. 设置View到ViewRootImpl
            root.setView(view, wparams, panelParentView);
        } catch (RuntimeException e) {
            synchronized (mLock) {
                final int index = findViewLocked(view, false);
                if (index >= 0) {
                    removeViewLocked(index, true);
                }
            }
            throw e;
        }
    }
}

7.2 ViewRootImpl.setView()

// frameworks/base/core/java/android/view/ViewRootImpl.java
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
    synchronized (this) {
        if (mView == null) {
            mView = view;

            // 1. 请求布局
            requestLayout();

            // 2. 添加窗口到WMS
            try {
                mOrigWindowType = mWindowAttributes.type;
                mAttachInfo.mRecomputeGlobalAttributes = true;

                res = mWindowSession.addToDisplay(
                    mWindow,
                    mSeq,
                    mWindowAttributes,
                    getHostVisibility(),
                    mDisplay.getDisplayId(),
                    mTmpFrame,
                    mAttachInfo.mContentInsets,
                    mAttachInfo.mStableInsets,
                    mAttachInfo.mOutsets,
                    mAttachInfo.mDisplayCutout,
                    mInputChannel,
                    mTempInsets
                );
            } catch (RemoteException e) {
                throw new RuntimeException("Adding window failed", e);
            }

            // 3. 注册输入事件通道
            if (mInputChannel != null) {
                mInputEventReceiver = new WindowInputEventReceiver(
                    mInputChannel,
                    Looper.myLooper()
                );
            }

            // 4. 设置View的Parent为ViewRootImpl
            view.assignParent(this);
        }
    }
}

7.3 requestLayout()

@Override
public void requestLayout() {
    if (!mHandlingLayoutInLayoutRequest) {
        checkThread();  // 检查是否在主线程
        mLayoutRequested = true;
        scheduleTraversals();  // 安排遍历
    }
}

void scheduleTraversals() {
    if (!mTraversalScheduled) {
        mTraversalScheduled = true;

        // 1. 同步屏障：优先处理UI绘制
        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();

        // 2. Choreographer安排下一帧回调
        mChoreographer.postCallback(
            Choreographer.CALLBACK_TRAVERSAL,
            mTraversalRunnable,
            null
        );
    }
}

final class TraversalRunnable implements Runnable {
    @Override
    public void run() {
        doTraversal();
    }
}

void doTraversal() {
    if (mTraversalScheduled) {
        mTraversalScheduled = false;

        // 移除同步屏障
        mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

        // 执行测量、布局、绘制
        performTraversals();
    }
}

7.4 performTraversals()

private void performTraversals() {
    final View host = mView;

    // 1. Measure阶段
    int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
    int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

    // 2. Layout阶段
    performLayout(lp, mWidth, mHeight);

    // 3. Draw阶段
    performDraw();
}

private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
    Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
    try {
        mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
}

private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
        int desiredWindowHeight) {
    mLayoutRequested = false;
    mScrollMayChange = true;
    mInLayout = true;

    final View host = mView;

    Trace.traceBegin(Trace.TRACE_TAG_VIEW, "layout");
    try {
        host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        mInLayout = false;
    }
}

private void performDraw() {
    try {
        boolean canUseAsync = draw(fullRedrawNeeded);

        if (mAttachInfo.mThreadedRenderer != null) {
            // 硬件加速渲染
            mAttachInfo.mThreadedRenderer.draw(mView, mAttachInfo, this);
        } else {
            // 软件渲染
            if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset,
                    scalingRequired, dirty, surfaceInsets)) {
                return;
            }
        }
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
}

7.5 WMS.addWindow()

// frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java
public int addWindow(Session session, IWindow client, int seq,
        LayoutParams attrs, int viewVisibility, int displayId, Rect outFrame,
        Rect outContentInsets, Rect outStableInsets,
        Rect outOutsets, DisplayCutout.ParcelableWrapper outDisplayCutout,
        InputChannel outInputChannel, InsetsState outInsetsState) {
    synchronized (mGlobalLock) {
        // 1. 权限检查
        final int type = attrs.type;
        if (type >= FIRST_SUB_WINDOW && type <= LAST_SUB_WINDOW) {
            // 子窗口需要父窗口
            parentWindow = windowForClientLocked(null, attrs.token, false);
            if (parentWindow == null) {
                return WindowManagerGlobal.ADD_BAD_SUBWINDOW_TOKEN;
            }
        }

        // 2. Token检查
        final DisplayContent displayContent = getDisplayContentOrCreate(displayId, attrs.token);
        if (displayContent == null) {
            return WindowManagerGlobal.ADD_INVALID_DISPLAY;
        }

        // 3. 创建WindowState
        final WindowState win = new WindowState(this, session, client, token, parentWindow,
                appOp[0], seq, attrs, viewVisibility, session.mUid,
                session.mCanAddInternalSystemWindow);

        // 4. 添加到窗口列表
        win.attach();
        mWindowMap.put(client.asBinder(), win);

        // 5. 分配Z-order
        displayContent.assignWindowLayers(false);

        // 6. 创建Surface
        win.getSurfaceControl(outSurfaceControl);

        // 7. 创建InputChannel
        if (outInputChannel != null) {
            String name = win.makeInputChannelName();
            InputChannel[] inputChannels = InputChannel.openInputChannelPair(name);
            win.setInputChannel(inputChannels[0]);
            inputChannels[1].transferTo(outInputChannel);

            mInputManager.registerInputChannel(win.mInputChannel, win.mInputWindowHandle);
        }

        return WindowManagerGlobal.ADD_OKAY;
    }
}

7.6 SurfaceFlinger合成

// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
void SurfaceFlinger::onMessageReceived(int32_t what) {
    switch (what) {
        case MessageQueue::INVALIDATE:
            handleMessageInvalidate();
            break;
        case MessageQueue::REFRESH:
            handleMessageRefresh();
            break;
    }
}

void SurfaceFlinger::handleMessageRefresh() {
    // 1. 准备帧
    preComposition();

    // 2. 重新计算可见区域
    rebuildLayerStacks();

    // 3. 合成图层
    doComposition();

    // 4. 显示到屏幕
    postComposition();
}

void SurfaceFlinger::doComposition() {
    const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);

    for (size_t dpy = 0; dpy < mDisplays.size(); dpy++) {
        const sp<DisplayDevice>& hw(mDisplays[dpy]);

        if (hw->isDisplayOn()) {
            // 1. 设置OpenGL上下文
            hw->makeCurrent(mEGLDisplay, mEGLContext);

            // 2. 合成该Display的所有Layer
            doDisplayComposition(hw, repaintEverything);

            // 3. 交换缓冲区（显示到屏幕）
            hw->swapBuffers(getHwComposer());
        }
    }
}

窗口显示流程总结：

Activity.onResume()
    ↓
WindowManager.addView(DecorView)
    ↓
ViewRootImpl.setView()
    ├─ WMS.addWindow() (创建WindowState、分配Z-order)
    ├─ requestLayout() (触发测量布局绘制)
    └─ 注册InputChannel (接收触摸事件)
    ↓
performTraversals()
    ├─ measure() (测量View尺寸)
    ├─ layout() (确定View位置)
    └─ draw() (绘制到Surface)
    ↓
SurfaceFlinger合成显示
    ↓
应用界面显示在屏幕上

八、阶段7：输入事件响应

8.1 InputManager分发事件

// frameworks/native/services/inputflinger/InputDispatcher.cpp
void InputDispatcher::dispatchOnce() {
    nsecs_t nextWakeupTime = LLONG_MAX;
    {
        AutoMutex _l(mLock);

        // 1. 从队列获取事件
        if (!haveCommandsLocked()) {
            dispatchOnceInnerLocked(&nextWakeupTime);
        }

        // 2. 执行命令
        runCommandsLockedInterruptible();
    }
}

void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
    // 1. 获取下一个事件
    EventEntry* entry = mPendingEvent;
    if (!entry) {
        if (mInboundQueue.isEmpty()) {
            return;
        }
        entry = mInboundQueue.dequeueAtHead();
        mPendingEvent = entry;
    }

    // 2. 分发事件
    switch (entry->type) {
        case EventEntry::TYPE_KEY:
            dispatchKeyLocked(currentTime, typedEntry, ...);
            break;
        case EventEntry::TYPE_MOTION:
            dispatchMotionLocked(currentTime, typedEntry, ...);
            break;
    }
}

void InputDispatcher::dispatchMotionLocked(
        nsecs_t currentTime,
        MotionEntry* entry,
        ...) {
    // 1. 查找目标窗口
    Vector<InputTarget> inputTargets;
    int32_t injectionResult = findFocusedWindowTargetsLocked(
        currentTime, entry, inputTargets, nextWakeupTime);

    // 2. 发送事件到目标窗口
    dispatchEventLocked(currentTime, entry, inputTargets);
}

void InputDispatcher::dispatchEventLocked(
        nsecs_t currentTime,
        EventEntry* eventEntry,
        const Vector<InputTarget>& inputTargets) {
    for (size_t i = 0; i < inputTargets.size(); i++) {
        const InputTarget& inputTarget = inputTargets.itemAt(i);

        // 通过InputChannel发送事件
        ssize_t connectionIndex = getConnectionIndexLocked(inputTarget.inputChannel);
        sp<Connection> connection = mConnectionsByFd.valueAt(connectionIndex);

        prepareDispatchCycleLocked(currentTime, connection, eventEntry, &inputTarget);
    }
}

8.2 ViewRootImpl接收事件

// frameworks/base/core/java/android/view/ViewRootImpl.java
final class WindowInputEventReceiver extends InputEventReceiver {
    @Override
    public void onInputEvent(InputEvent event) {
        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "processInputEvent");
        try {
            // 分发输入事件
            enqueueInputEvent(event, this, 0, true);
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }
    }
}

void enqueueInputEvent(InputEvent event, InputEventReceiver receiver,
        int flags, boolean processImmediately) {
    QueuedInputEvent q = obtainQueuedInputEvent(event, receiver, flags);

    if (processImmediately) {
        // 立即处理
        doProcessInputEvents();
    } else {
        // 安排异步处理
        scheduleProcessInputEvents();
    }
}

void doProcessInputEvents() {
    while (mPendingInputEventHead != null) {
        QueuedInputEvent q = mPendingInputEventHead;
        mPendingInputEventHead = q.mNext;

        // 分发事件到View树
        deliverInputEvent(q);
    }
}

private void deliverInputEvent(QueuedInputEvent q) {
    InputStage stage = q.shouldSkipIme() ? mFirstPostImeInputStage : mFirstInputStage;

    if (stage != null) {
        // 通过InputStage链处理事件
        stage.deliver(q);
    } else {
        finishInputEvent(q);
    }
}

8.3 DecorView分发到Activity

// frameworks/base/core/java/com/android/internal/policy/DecorView.java
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    // 1. 分发给Window.Callback (Activity)
    final Window.Callback cb = mWindow.getCallback();
    return cb != null && !mWindow.isDestroyed() && mFeatureId < 0
            ? cb.dispatchTouchEvent(ev) : super.dispatchTouchEvent(ev);
}

// frameworks/base/core/java/android/app/Activity.java
public boolean dispatchTouchEvent(MotionEvent ev) {
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
        onUserInteraction();  // 用户交互回调
    }

    // 分发给Window (PhoneWindow)
    if (getWindow().superDispatchTouchEvent(ev)) {
        return true;
    }

    // Window未消费，调用Activity.onTouchEvent()
    return onTouchEvent(ev);
}

// frameworks/base/core/java/com/android/internal/policy/PhoneWindow.java
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
    // 分发给DecorView
    return mDecor.superDispatchTouchEvent(event);
}

// DecorView.superDispatchTouchEvent()
public boolean superDispatchTouchEvent(MotionEvent event) {
    // 调用ViewGroup.dispatchTouchEvent()
    return super.dispatchTouchEvent(event);
}

触摸事件分发链：

InputDispatcher (Native)
    ↓ InputChannel
ViewRootImpl.WindowInputEventReceiver
    ↓
DecorView.dispatchTouchEvent()
    ↓
Activity.dispatchTouchEvent()
    ↓
PhoneWindow.superDispatchTouchEvent()
    ↓
DecorView.superDispatchTouchEvent()
    ↓
ViewGroup.dispatchTouchEvent()
    ↓
View树递归分发

九、性能优化与最佳实践

9.1 启动性能优化

冷启动优化

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        // ✓ 延迟初始化非关键组件
        if (isMainProcess()) {
            // 主进程初始化
            initCriticalComponents()

            // 使用IdleHandler延迟初始化
            Looper.myQueue().addIdleHandler {
                initNonCriticalComponents()
                false  // 执行一次后移除
            }
        }
    }

    private fun initCriticalComponents() {
        // 关键组件：立即初始化
        initCrashReporter()
        initNetworkLayer()
    }

    private fun initNonCriticalComponents() {
        // 非关键组件：空闲时初始化
        initImageLoader()
        initAnalytics()
    }
}

ContentProvider延迟加载

<!-- AndroidManifest.xml -->
<provider
    android:name=".InitProvider"
    android:authorities="${applicationId}.initprovider"
    android:exported="false"
    android:enabled="false">  <!-- 禁用自动加载 -->
</provider>

// 手动初始化
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // 延迟到Activity.onCreate()再初始化Provider
        if (!isProviderInitialized) {
            val providerInfo = packageManager.resolveContentProvider(
                "${packageName}.initprovider", 0)
            // 手动初始化Provider
            isProviderInitialized = true
        }
    }
}

启动窗口优化

<!-- themes.xml -->
<style name="AppTheme.Launcher" parent="AppTheme">
    <!-- 设置启动窗口背景 -->
    <item name="android:windowBackground">@drawable/launch_screen</item>
    <!-- 避免黑屏 -->
    <item name="android:windowDisablePreview">false</item>
</style>

<!-- AndroidManifest.xml -->
<activity
    android:name=".MainActivity"
    android:theme="@style/AppTheme.Launcher">  <!-- 启动主题 -->
    <intent-filter>
        <action android:name="android.intent.action.MAIN"/>
        <category android:name="android.intent.category.LAUNCHER"/>
    </intent-filter>
</activity>

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        // 切换到正常主题
        setTheme(R.style.AppTheme)
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

9.2 内存优化

// ✓ 避免在Application.onCreate()中创建大对象
class MyApplication : Application() {
    // ✗ 错误：全局单例持有Context
    companion object {
        lateinit var instance: MyApplication  // 内存泄漏风险
    }

    override fun onCreate() {
        super.onCreate()
        instance = this  // 避免这样做
    }
}

// ✓ 正确：使用ApplicationContext
object AppContext {
    lateinit var context: Context
        private set

    fun init(context: Context) {
        this.context = context.applicationContext  // 使用ApplicationContext
    }
}

9.3 ANR避免

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // ✗ 错误：主线程执行耗时操作
        // loadDataFromNetwork()  // 会导致ANR

        // ✓ 正确：异步执行
        lifecycleScope.launch(Dispatchers.IO) {
            val data = loadDataFromNetwork()

            withContext(Dispatchers.Main) {
                // 切回主线程更新UI
                updateUI(data)
            }
        }
    }
}

9.4 启动追踪

// 使用Trace API追踪启动性能
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        Trace.beginSection("Application.onCreate")
        try {
            initComponents()
        } finally {
            Trace.endSection()
        }
    }

    private fun initComponents() {
        Trace.beginSection("initCriticalComponents")
        initCriticalComponents()
        Trace.endSection()

        Trace.beginSection("initNonCriticalComponents")
        initNonCriticalComponents()
        Trace.endSection()
    }
}

查看Trace：

# 使用systrace抓取启动trace
adb shell am start -W -n com.example.app/.MainActivity
python systrace.py --time=10 -o trace.html sched freq idle am wm gfx view \
    binder_driver hal dalvik camera input res

# 或使用Android Studio Profiler的CPU Profiler

十、调试技巧

10.1 应用启动日志

# 查看Activity启动日志
adb logcat -s ActivityManager:V

# 输出示例
ActivityManager: START u0 {act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10000000 cmp=com.example.app/.MainActivity} from uid 10123
ActivityManager: Start proc 12345:com.example.app/u0a123 for activity com.example.app/.MainActivity

10.2 启动时间测量

# 使用am命令测量启动时间
adb shell am start -W com.example.app/.MainActivity

# 输出
Starting: Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] cmp=com.example.app/.MainActivity }
Status: ok
LaunchState: COLD
Activity: com.example.app/.MainActivity
TotalTime: 856      # 总启动时间
WaitTime: 862       # 等待时间

时间含义：

• TotalTime: 从startActivity到Activity.onResume()完成的时间
• WaitTime: 包含系统处理时间，通常略大于TotalTime

10.3 systrace分析

# 抓取应用启动的systrace
python systrace.py -a com.example.app -o trace.html \
    sched freq idle am wm gfx view binder_driver hal dalvik

# 在Chrome中打开trace.html
# 使用W/S放大缩小，A/D左右移动
# 按M键查看统计信息

关键指标：

• Zygote fork时间: fork()系统调用耗时
• Application.onCreate(): 应用初始化耗时
• Activity.onCreate(): Activity创建耗时
• 首帧绘制时间: performTraversals()到首帧显示

10.4 Perfetto分析

# Android 10+推荐使用Perfetto
adb shell perfetto \
  -c - --txt \
  -o /data/misc/perfetto-traces/trace \
<<EOF
buffers: {
    size_kb: 63488
    fill_policy: DISCARD
}
data_sources: {
    config {
        name: "linux.ftrace"
        ftrace_config {
            ftrace_events: "sched/sched_switch"
            ftrace_events: "sched/sched_wakeup"
            atrace_categories: "am"
            atrace_categories: "wm"
            atrace_categories: "gfx"
            atrace_categories: "view"
        }
    }
}
duration_ms: 10000
EOF

# 拉取trace文件
adb pull /data/misc/perfetto-traces/trace perfetto-trace.pb

# 在ui.perfetto.dev中打开分析

十一、Android 15新特性

11.1 改进的应用启动性能

// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
// Android 15: 并行化ContentProvider安装
private void installContentProvidersParallel(
        IApplicationThread caller,
        List<ProviderInfo> providers) {
    // 1. 按依赖关系排序
    List<ProviderInfo> sortedProviders = sortProvidersByDependency(providers);

    // 2. 使用线程池并行安装
    ExecutorService executor = Executors.newFixedThreadPool(
        Math.min(4, Runtime.getRuntime().availableProcessors()));

    List<Future<ContentProvider>> futures = new ArrayList<>();
    for (ProviderInfo cpi : sortedProviders) {
        futures.add(executor.submit(() -> installProvider(caller, cpi)));
    }

    // 3. 等待所有Provider安装完成
    for (Future<ContentProvider> future : futures) {
        try {
            future.get();
        } catch (Exception e) {
            Log.e(TAG, "Failed to install provider", e);
        }
    }

    executor.shutdown();
}

11.2 优化的窗口创建

// Android 15: 预创建Surface
public class ViewRootImpl {
    private Surface mPreCreatedSurface;

    public void setView(View view, ...) {
        // 如果有预创建的Surface，直接使用
        if (mPreCreatedSurface != null) {
            mSurface.copyFrom(mPreCreatedSurface);
            mPreCreatedSurface = null;
        } else {
            // 传统方式：通过WMS创建
            mWindowSession.addToDisplay(...);
        }
    }

    // 预创建Surface（在Activity启动之前）
    public static void preCreateSurface(String packageName) {
        Surface surface = new Surface();
        SurfaceControl.openTransaction();
        try {
            SurfaceControl sc = new SurfaceControl.Builder()
                .setName("PreCreated-" + packageName)
                .build();
            surface.copyFrom(sc);
        } finally {
            SurfaceControl.closeTransaction();
        }
        sSurfaceCache.put(packageName, surface);
    }
}

11.3 增强的启动追踪

// Android 15: 自动启动追踪
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        // 系统自动记录启动关键节点
        // 无需手动调用Trace API

        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 可通过dumpsys查看启动统计
        // adb shell dumpsys activity startup-metrics com.example.app
    }
}

十二、总结

核心知识点回顾

通过本篇文章，我们完整追踪了从点击Launcher图标到应用显示的全流程，涉及以下核心服务：

1. Launcher - 用户交互入口，通过Binder调用AMS
2. ActivityManagerService - 统筹Activity启动，管理进程生命周期
3. PackageManagerService - 解析Intent，查询Activity信息
4. Zygote - 通过fork()孵化新进程，Copy-on-Write优化
5. ActivityThread - 应用主线程，管理Application和Activity生命周期
6. WindowManagerService - 管理窗口层级，分配Z-order
7. ViewRootImpl - 连接View和WMS，执行measure/layout/draw
8. SurfaceFlinger - 图形合成，显示到屏幕
9. InputManagerService - 输入事件分发，实现触摸交互

通信机制总结

通信场景	通信方式	特点
Launcher → AMS	Binder IPC	同步调用，跨进程
AMS → Zygote	Socket	LocalSocket，可靠传输
AMS → App	Binder (ApplicationThread)	异步回调，生命周期管理
App → WMS	Binder (IWindowSession)	同步调用，窗口操作
WMS → SurfaceFlinger	Binder + 共享内存	GraphicBuffer共享
InputManager → App	InputChannel (Socket Pair)	事件分发，低延迟

性能优化要点

1. 减少Application.onCreate()耗时 - 延迟初始化、异步加载
2. 避免ContentProvider阻塞 - 禁用自动加载或并行初始化
3. 优化Activity.onCreate() - 减少布局层级、懒加载数据
4. 设置启动窗口 - 避免白屏/黑屏，提升用户体验
5. 使用Trace追踪 - 定位性能瓶颈，持续优化

系列完结

至此，《Android 15核心子系统系列》全部27篇文章圆满完成！

我们从最底层的Binder跨进程通信开始，一步步深入到系统启动、进程管理、包管理、窗口管理、输入系统、电源管理、通知管理、任务调度、数据共享，最后在本篇串联所有知识点，完整展现了Android系统的宏伟架构。

希望这个系列能帮助你：

• 建立系统级的Android开发思维
• 理解Framework层的设计哲学
• 具备分析和解决复杂系统问题的能力
• 为成为Android系统级工程师打下坚实基础

感谢陪伴！期待在Android系统的世界里与你再次相遇！

---

参考源码（基于Android 15 AOSP）：

• frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
• frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java
• frameworks/base/core/java/android/app/ActivityThread.java
• frameworks/base/core/java/android/view/ViewRootImpl.java
• frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
• frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
• frameworks/native/services/inputflinger/InputDispatcher.cpp

调试命令速查：

# 启动时间测量
adb shell am start -W com.example.app/.MainActivity

# 启动日志
adb logcat -s ActivityManager:V

# systrace抓取
python systrace.py -a com.example.app -o trace.html \
    sched freq idle am wm gfx view binder_driver

# Perfetto抓取
adb shell perfetto -o /data/misc/perfetto-traces/trace -t 10s \
    sched freq am wm gfx view

系列导航：

• 上一篇：ContentProvider与Uri权限：跨应用数据共享

---

本文基于Android 15 (API Level 35)源码分析,不同厂商的定制ROM可能存在差异。 欢迎来我中的个人主页找到更多有用的知识和有趣的产品