Android应用启动流程源码级解析

木易 士心2026-04-01 12:17

目录

    • 概述
    • 阶段一：Launcher发起启动请求
      • [1.1 Launcher点击事件处理](#1.1 Launcher点击事件处理)
      • [1.2 Activity启动调用链](#1.2 Activity启动调用链)
      • [1.3 Instrumentation跨进程调用](#1.3 Instrumentation跨进程调用)
    • 阶段二：系统服务处理与进程创建
      • [2.1 ActivityTaskManagerService处理](#2.1 ActivityTaskManagerService处理)
      • [2.2 ActivityStarter执行启动](#2.2 ActivityStarter执行启动)
      • [2.3 进程创建流程](#2.3 进程创建流程)
    • 阶段三：Zygote进程孵化
      • [3.1 Zygote进程处理fork请求](#3.1 Zygote进程处理fork请求)
      • [3.2 子进程初始化](#3.2 子进程初始化)
    • 阶段四：应用进程初始化
      • [4.1 ActivityThread主线程初始化](#4.1 ActivityThread主线程初始化)
      • [4.2 ApplicationThread Binder接口](#4.2 ApplicationThread Binder接口)
      • [4.3 处理BIND_APPLICATION消息](#4.3 处理BIND_APPLICATION消息)
    • 阶段五：Activity实例化与显示
      • [5.1 调度Activity启动](#5.1 调度Activity启动)
      • [5.2 处理LAUNCH_ACTIVITY事务](#5.2 处理LAUNCH_ACTIVITY事务)
      • [5.3 ActivityThread处理启动](#5.3 ActivityThread处理启动)
      • [5.4 处理Resume和界面显示](#5.4 处理Resume和界面显示)
    • 阶段六：界面绘制流程
      • [6.1 ViewRootImpl与界面绘制](#6.1 ViewRootImpl与界面绘制)
      • [6.2 完整的绘制流程](#6.2 完整的绘制流程)
    • 核心机制总结
    • 核心概念与组件

概述

在Android系统中，从点击应用图标到界面显示的过程涉及多个进程间的复杂协作。下面我将结合源码，为你深入解析这一过程的各个阶段，包括Launcher发起请求、AMS/ATMS处理、进程创建及Activity初始化与UI绘制等关键环节。整个过程可参考以下时序图：

阶段一：Launcher发起启动请求

1.1 Launcher点击事件处理

源码位置 ： packages/apps/Launcher3/src/com/android/launcher3/Launcher.java

java 复制代码 
// Launcher.java
public void onClick(View v) {
    Object tag = v.getTag();
    if (tag instanceof ShortcutInfo) {
        // 点击的是应用图标
        ShortcutInfo shortcut = (ShortcutInfo) tag;
        Intent intent = shortcut.getIntent();
        startActivitySafely(v, intent, shortcut);
    }
}

public boolean startActivitySafely(View v, Intent intent, Object item) {
    // 添加NEW_TASK标志
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    try {
        startActivity(intent, optsBundle);
        return true;
    } catch (ActivityNotFoundException|SecurityException e) {
        // 异常处理
    }
    return false;
}

1.2 Activity启动调用链

源码位置 ： frameworks/base/core/java/android/app/Activity.java

java 复制代码 
// Activity.java
public void startActivity(Intent intent, @Nullable Bundle options) {
    if (options != null) {
        startActivityForResult(intent, -1, options);
    } else {
        startActivityForResult(intent, -1);
    }
}

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
        @Nullable Bundle options) {
    if (mParent == null) {
        options = transferSpringboardActivityOptions(options);
        // 关键调用：通过Instrumentation启动Activity
        Instrumentation.ActivityResult ar =
            mInstrumentation.execStartActivity(
                this, mMainThread.getApplicationThread(), mToken, this,
                intent, requestCode, options);
        // ... 处理结果
    }
}

1.3 Instrumentation跨进程调用

源码位置 ： frameworks/base/core/java/android/app/Instrumentation.java

java 复制代码 
// Instrumentation.java
public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
    IApplicationThread whoThread = (IApplicationThread) contextThread;
    
    try {
        intent.migrateExtraStreamToClipData();
        intent.prepareToLeaveProcess(who);
        // 关键：通过ActivityTaskManager跨进程调用
        int result = ActivityTaskManager.getService()
            .startActivity(whoThread, who.getBasePackageName(), intent,
                    intent.resolveTypeIfNeeded(who.getContentResolver()),
                    token, target != null ? target.mEmbeddedID : null,
                    requestCode, 0, null, options);
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

阶段二：系统服务处理与进程创建

2.1 ActivityTaskManagerService处理

源码位置 ： frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java

java 复制代码 
// ActivityTaskManagerService.java
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
    return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
            resultWho, requestCode, startFlags, profilerInfo, bOptions,
            UserHandle.getCallingUserId());
}

private int startActivityAsUser(...) {
    // 权限检查
    enforceNotIsolatedCaller("startActivity");
    userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
            Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");

    // 使用ActivityStarter处理启动逻辑
    return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
            .setCaller(caller)
            .setCallingPackage(callingPackage)
            .setResolvedType(resolvedType)
            .setResultTo(resultTo)
            .setResultWho(resultWho)
            .setRequestCode(requestCode)
            .setStartFlags(startFlags)
            .setProfilerInfo(profilerInfo)
            .setActivityOptions(bOptions)
            .setUserId(userId)
            .execute();
}

2.2 ActivityStarter执行启动

源码位置 ： frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java

java 复制代码 
// ActivityStarter.java
int execute() {
    try {
        if (mRequest.activityInfo == null) {
            // 解析Intent，获取ActivityInfo
            mRequest.resolveActivity(mSupervisor);
        }
        
        int res;
        synchronized (mService.mGlobalLock) {
            // 权限检查
            res = validateTargetActivity();
            if (res != START_SUCCESS) {
                return res;
            }
            
            // 执行启动
            res = executeRequest(mRequest);
        }
        return res;
    } finally {
        onExecutionComplete();
    }
}

private int executeRequest(Request request) {
    // 创建ActivityRecord
    final ActivityRecord r = new ActivityRecord(...);
    
    // 检查目标进程
    final boolean forceNewProcess = (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0;
    ProcessRecord app = mService.getProcessRecordLocked(r.processName, r.appInfo.uid);
    
    if (app != null && app.hasThread()) {
        // 进程已存在，直接启动Activity
        try {
            mService.startActivityInPackage(...);
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    } else {
        // 进程不存在，需要创建新进程
        mService.startProcessAsync(r, knownToBeDead, knownToBeDead,
                "activity", r.intent.getComponent());
    }
    return START_SUCCESS;
}

2.3 进程创建流程

源码位置 ： frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

java 复制代码 
// ActivityManagerService.java
final ProcessRecord startProcessLocked(ProcessRecord app, String hostingType,
        String hostingNameStr, boolean disableHiddenApiChecks,
        boolean disableTestApiChecks, String abiOverride) {
    long startTime = SystemClock.uptimeMillis();
    
    // 准备启动参数
    String entryPoint = "android.app.ActivityThread";
    
    // 调用Process.start
    return startProcessLocked(hostingType, entryPoint, app, uid, gids,
            runtimeFlags, zygotePolicyFlags, mountExternal, seInfo, requiredAbi,
            instructionSet, invokeWith, startTime);
}

private ProcessRecord startProcessLocked(...) {
    final ProcessStartResult startResult;
    if (hostingType.equals("webview_service")) {
        // 启动WebView进程
        startResult = startWebView(entryPoint, ...);
    } else {
        // 通过Zygote进程fork新进程
        startResult = Process.start(entryPoint,
                app.processName, uid, uid, gids, runtimeFlags, mountExternal,
                app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
                app.info.dataDir, invokeWith, app.info.packageName,
                new String[] {PROC_START_SEQ_IDENT + app.startSeq});
    }
    
    // 记录进程信息
    app.setPid(startResult.pid);
    app.usingWrapper = startResult.usingWrapper;
    app.startSeq = startResult.startSeq;
    mProcessNames.put(app.processName, app.uid, app);
    
    return app;
}

阶段三：Zygote进程孵化

3.1 Zygote进程处理fork请求

源码位置 ： frameworks/base/core/java/com/android/internal/os/ZygoteServer.java

java 复制代码 
// ZygoteServer.java
Runnable runSelectLoop(String abiList) {
    while (true) {
        // 监听Socket连接
        ZygoteConnection connection = peers.get(i);
        final Runnable command = connection.processOneCommand(this);
        
        if (command != null) {
            return command;
        }
    }
}

源码位置 ： frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java

java 复制代码 
// ZygoteConnection.java
Runnable processOneCommand(ZygoteServer zygoteServer) {
    String args[];
    Arguments parsedArgs = null;
    FileDescriptor[] descriptors;

    try {
        // 读取启动参数
        args = readArgumentList();
        descriptors = mSocket.getAncillaryFileDescriptors();
    } catch (IOException ex) {
        throw new IllegalStateException("IOException on command socket", ex);
    }

    // 解析参数
    parsedArgs = new Arguments(args);
    
    // 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);

    if (pid == 0) {
        // 在子进程中
        zygoteServer.setForkChild();
        zygoteServer.closeServerSocket();
        IoUtils.closeQuietly(serverPipeFd);
        serverPipeFd = null;
        
        // 处理子进程
        return handleChildProc(parsedArgs, descriptors, childPipeFd,
                parsedArgs.startChildZygote);
    } else {
        // 在父进程(Zygote)中
        return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
    }
}

3.2 子进程初始化

源码位置 ： frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

java 复制代码 
// ZygoteInit.java
private static Runnable handleChildProc(Arguments parsedArgs, FileDescriptor[] descriptors,
        FileDescriptor pipeFd, boolean isZygote) {
    // 关闭Zygote的Socket
    closeServerSocket();
    
    if (parsedArgs.mRuntimeFlags != 0) {
        Zygote.setAppProcessName(parsedArgs, TAG);
    }
    
    if (parsedArgs.mInvokeWith != null) {
        // 使用包装器启动
        WrapperInit.execApplication(parsedArgs.mInvokeWith,
                parsedArgs.mAppDataDir, parsedArgs.mNiceName, parsedArgs.mTargetSdkVersion,
                VMRuntime.getCurrentInstructionSet(),
                pipeFd, parsedArgs.mRemainingArgs);
    } else {
        if (!isZygote) {
            // 正常应用进程启动
            return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion,
                    parsedArgs.mRemainingArgs, null);
        } else {
            // Zygote进程启动
            return ZygoteInit.childZygoteInit(parsedArgs.mRemainingArgs);
        }
    }
    return null;
}

public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, 
        ClassLoader classLoader) {
    // 通用初始化
    RuntimeInit.commonInit();
    // 原生Zygote初始化
    ZygoteInit.nativeZygoteInit();
    // 应用初始化
    return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}

阶段四：应用进程初始化

4.1 ActivityThread主线程初始化

源码位置 ： frameworks/base/core/java/android/app/ActivityThread.java

java 复制代码 
// ActivityThread.java
public static void main(String[] args) {
    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
    
    // 初始化主线程Looper
    Looper.prepareMainLooper();
    
    // 创建ActivityThread实例
    ActivityThread thread = new ActivityThread();
    thread.attach(false, startSeq);
    
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
    
    // 开始消息循环
    Looper.loop();
    
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

private void attach(boolean system, long startSeq) {
    sCurrentActivityThread = this;
    mSystemThread = system;
    if (!system) {
        // 应用进程attach到系统服务
        final IActivityManager mgr = ActivityManager.getService();
        try {
            mgr.attachApplication(mAppThread, startSeq);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    } else {
        // 系统进程初始化
        // ...
    }
}

4.2 ApplicationThread Binder接口

源码位置 ： frameworks/base/core/java/android/app/ActivityThread.java

java 复制代码 
// ActivityThread.java - ApplicationThread内部类
private class ApplicationThread extends IApplicationThread.Stub {
    @Override
    public final void bindApplication(String processName, ApplicationInfo appInfo,
            List<ProviderInfo> providers, ComponentName instrumentationName,
            ProfilerInfo profilerInfo, Bundle instrumentationArgs,
            IInstrumentationWatcher instrumentationWatcher,
            IUiAutomationConnection instrumentationUiConnection, int debugMode,
            boolean enableBinderTracking, boolean trackAllocation,
            boolean isRestrictedBackupMode, boolean persistent, Configuration config,
            CompatibilityInfo compatInfo, Map services, Bundle coreSettings,
            String buildSerial, AutofillOptions autofillOptions,
            ContentCaptureOptions contentCaptureOptions, long[] disabledCompatChanges) {
        
        // 发送BIND_APPLICATION消息到主线程
        sendMessage(H.BIND_APPLICATION, data);
    }
}

4.3 处理BIND_APPLICATION消息

java 复制代码 
// ActivityThread.java
private void handleBindApplication(AppBindData data) {
    // 设置进程名
    Process.setArgV0(data.processName);
    
    // 创建Application的Context
    final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
    
    // 创建Instrumentation
    if (data.instrumentationName != null) {
        // ...
    } else {
        mInstrumentation = new Instrumentation();
    }
    
    // 创建Application
    Application app = data.info.makeApplication(data.restrictedBackupMode, null);
    mInitialApplication = app;
    
    // 安装ContentProviders
    if (!data.restrictedBackupMode) {
        if (!ArrayUtils.isEmpty(data.providers)) {
            installContentProviders(app, data.providers);
        }
    }
    
    // 调用Application.onCreate()
    mInstrumentation.callApplicationOnCreate(app);
}

阶段五：Activity实例化与显示

5.1 调度Activity启动

源码位置 ： frameworks/base/services/core/java/com/android/server/wm/ActivityStackSupervisor.java

java 复制代码 
// ActivityStackSupervisor.java
final boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
        boolean andResume, boolean checkConfig) throws RemoteException {
    
    // 创建启动事务
    final ClientTransaction clientTransaction = ClientTransaction.obtain(
            proc.getThread(), r.appToken);
    
    // 添加LaunchActivityItem回调
    clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
            System.identityHashCode(r), r.info,
            mergedConfiguration.getGlobalConfiguration(),
            mergedConfiguration.getOverrideConfiguration(), r.compat,
            r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
            r.icicle, r.persistentState, results, newIntents,
            dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
            r.assistToken, r.createFixedRotationAdjustmentsIfNeeded()));
    
    // 设置生命周期状态
    final ActivityLifecycleItem lifecycleItem;
    if (andResume) {
        lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
    } else {
        lifecycleItem = PauseActivityItem.obtain();
    }
    clientTransaction.setLifecycleStateRequest(lifecycleItem);
    
    // 调度事务
    mService.getLifecycleManager().scheduleTransaction(clientTransaction);
    
    return true;
}

5.2 处理LAUNCH_ACTIVITY事务

源码位置 ： frameworks/base/core/java/android/app/servertransaction/LaunchActivityItem.java

java 复制代码 
// LaunchActivityItem.java
@Override
public void execute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    // 创建ActivityClientRecord
    ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
            mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
            mPendingResults, mPendingNewIntents, mIsForward,
            mProfilerInfo, client, mAssistToken, mFixedRotationAdjustments);
    
    // 调用ActivityThread处理启动
    client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
}

5.3 ActivityThread处理启动

java 复制代码 
// ActivityThread.java
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
        PendingTransactionActions pendingActions, Intent customIntent) {
    
    // 初始化WindowManager等
    WindowManagerGlobal.initialize();
    
    // 执行Activity启动
    final Activity a = performLaunchActivity(r, customIntent);
    
    if (a != null) {
        // 处理Resume
        handleResumeActivity(r.token, false, r.isForward,
                !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
    }
    
    return a;
}

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    // 获取ActivityInfo
    ActivityInfo aInfo = r.activityInfo;
    if (r.packageInfo == null) {
        r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                Context.CONTEXT_INCLUDE_CODE);
    }
    
    ComponentName component = r.intent.getComponent();
    if (component == null) {
        component = r.intent.resolveActivity(
            mInitialApplication.getPackageManager());
        r.intent.setComponent(component);
    }
    
    // 创建Activity实例
    Activity activity = null;
    try {
        java.lang.ClassLoader cl = appContext.getClassLoader();
        activity = mInstrumentation.newActivity(
                cl, component.getClassName(), r.intent);
    } catch (Exception e) {
        // 异常处理
    }
    
    try {
        // 创建Application（如果尚未创建）
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);
        
        if (activity != null) {
            // 创建Context
            Context appContext = createBaseContextForActivity(r, activity);
            CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
            Configuration config = new Configuration(mCompatConfiguration);
            
            // 调用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,
                    r.assistToken);
            
            // 设置主题
            int theme = r.activityInfo.getThemeResource();
            if (theme != 0) {
                activity.setTheme(theme);
            }
            
            // 调用onCreate()
            if (r.isPersistable()) {
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }
        }
        
        r.setState(ON_CREATE);
    } catch (SuperNotCalledException e) {
        throw e;
    } catch (Exception e) {
        // 异常处理
    }
    
    return activity;
}

5.4 处理Resume和界面显示

java 复制代码 
// ActivityThread.java
@Override
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
        boolean shouldSendCompatFakeFocus, String reason) {
    
    // 最终执行onResume()
    final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
    
    if (r.activity != null) {
        final Activity a = r.activity;
        
        if (r.window == null && !a.mFinished && willBeVisible) {
            // 获取Window
            r.window = r.activity.getWindow();
            View decor = r.window.getDecorView();
            decor.setVisibility(View.INVISIBLE);
            
            // 获取ViewManager（通常是WindowManager）
            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;
                    // 关键：将DecorView添加到WindowManager
                    wm.addView(decor, l);
                } else {
                    a.onWindowAttributesChanged(l);
                }
            }
        }
        
        // 使界面可见
        if (!r.activity.mFinished && willBeVisible && r.activity.mDecor != null && !r.hideForNow) {
            if (r.activity.mVisibleFromClient) {
                // 调用makeVisible()，实际显示界面
                r.activity.makeVisible();
            }
        }
    }
}

阶段六：界面绘制流程

6.1 ViewRootImpl与界面绘制

源码位置 ： frameworks/base/core/java/android/view/ViewRootImpl.java

java 复制代码 
// ViewRootImpl.java
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
    synchronized (this) {
        if (mView == null) {
            mView = view;
            
            // 请求布局
            requestLayout();
            
            // 添加窗口到WindowManagerService
            res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                    getHostVisibility(), mDisplay.getDisplayId(), mTmpFrame,
                    mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                    mAttachInfo.mOutsets, mAttachInfo.mDisplayCutout, mInputChannel,
                    mTempInsets);
        }
    }
}

@Override
public void requestLayout() {
    if (!mHandlingLayoutInLayoutRequest) {
        checkThread();
        mLayoutRequested = true;
        // 安排遍历（测量、布局、绘制）
        scheduleTraversals();
    }
}

void scheduleTraversals() {
    if (!mTraversalScheduled) {
        mTraversalScheduled = true;
        // 发送同步屏障，确保UI操作优先执行
        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
        // 使用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);
        
        // 执行完整的UI遍历
        performTraversals();
    }
}

private void performTraversals() {
    // 测量阶段
    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
    
    // 布局阶段  
    performLayout(lp, desiredWindowWidth, desiredWindowHeight);
    
    // 绘制阶段
    performDraw();
}

6.2 完整的绘制流程

java 复制代码 
// ViewRootImpl.java
private void performTraversals() {
    final View host = mView;
    
    // 1. 测量
    if (layoutRequested) {
        windowSizeMayChange |= measureHierarchy(host, lp, res,
                desiredWindowWidth, desiredWindowHeight);
    }
    
    // 2. 布局
    if (didLayout) {
        performLayout(lp, mWidth, mHeight);
    }
    
    // 3. 绘制
    if (!cancelDraw && !newSurface) {
        if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
            for (int i = 0; i < mPendingTransitions.size(); ++i) {
                mPendingTransitions.get(i).startChangingAnimations();
            }
            mPendingTransitions.clear();
        }
        
        performDraw();
    }
}

private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
    if (mView != null) {
        Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
        try {
            // 调用View的measure方法
            mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }
    }
}

private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
        int desiredWindowHeight) {
    final View host = mView;
    Trace.traceBegin(Trace.TRACE_TAG_VIEW, "layout");
    try {
        // 调用View的layout方法
        host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
}

private void performDraw() {
    if (mAttachInfo.mDisplayState == Display.STATE_OFF && !mReportNextDraw) {
        return;
    }
    
    final boolean fullRedrawNeeded = mFullRedrawNeeded;
    mFullRedrawNeeded = false;
    
    // 开始绘制
    boolean canUseAsync = draw(fullRedrawNeeded);
    
    if (usingAsyncReport && !runnableAdded) {
        mAttachInfo.mViewRootImpl.addFrameCommitCallbackIfNeeded();
    }
}

private boolean draw(boolean fullRedrawNeeded) {
    Surface surface = mSurface;
    if (!surface.isValid()) {
        return false;
    }
    
    if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset,
            scalingRequired, dirty, surfaceInsets)) {
        return false;
    }
    
    return true;
}

private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
        boolean scalingRequired, Rect dirty, Rect surfaceInsets) {
    
    final Canvas canvas;
    try {
        // 锁定Canvas进行绘制
        canvas = mSurface.lockCanvas(dirty);
    } catch (Surface.OutOfResourcesException e) {
        return false;
    } catch (IllegalArgumentException e) {
        return false;
    }
    
    try {
        // 实际的绘制操作
        mView.draw(canvas);
    } finally {
        try {
            // 解锁并提交Canvas
            surface.unlockCanvasAndPost(canvas);
        } catch (IllegalArgumentException e) {
            // 异常处理
        }
    }
    return true;
}

核心机制总结

整个Android应用启动流程涉及的关键机制：

  1. Binder IPC：Launcher→AMS、AMS→Zygote、AMS→ApplicationThread的跨进程通信
  2. Socket通信：AMS向Zygote请求fork新进程
  3. Zygote机制：预加载类资源和资源，快速fork新进程
  4. Handler机制：应用进程主线程消息循环处理
  5. WindowManager：窗口管理和界面显示
  6. View系统：测量、布局、绘制的完整UI流水线

核心概念与组件

  • ActivityTaskManagerService(ATMS)/ActivityManagerService(AMS)：系统核心服务，调度和管理Activity生命周期
  • Zygote：Android进程孵化器，通过复制自身快速创建新应用进程
  • ActivityThread：应用进程的主线程，接收AMS/ATMS指令并调度生命周期
  • Instrumentation：管理类，监控Activity创建及生命周期回调
  • Binder IPC：Launcher、AMS/ATMS、应用进程之间的跨进程通信机制
  • ApplicationThread：ActivityThread的内部类，作为Binder接口供AMS/ATMS回调应用进程
相关推荐
八宝粥大朋友2 小时前
Android sqlite3 编译及安装
android·java·sqlite
ego.iblacat3 小时前
MySQL 主从复制与读写分离
android·mysql·adb
Android系统攻城狮3 小时前
Android tinyalsa深度解析之pcm_params_get_period_size_max调用流程与实战(一百七十二)
android·pcm·tinyalsa·音频进阶
空空kkk3 小时前
MySQL 主从同步
android·数据库·mysql
weiggle3 小时前
Android View绘制流程深度解析
android
dora4 小时前
Android弱网优化 —— 都要卫星互联网了，谁给我限速体验2G
android·性能优化
用户3171478611334 小时前
仿今日头条 APP 开发实战：RecyclerView 核心玩法 + 全布局体系深度拆解
android
用户41659673693554 小时前
在 Jetpack Compose 中实现拼音与四线三格的精准对齐
android
用户69371750013844 小时前
太钻 Android 了，在电鸭刷私活把我自己刷清醒了
android·前端·github
热门推荐
012026年3月AI领域大事件：DeepSeek引领开源风暴02GitHub 镜像站点03围棋-html版本04纯 HTML/CSS/JS 实现的高颜值登录页，还会眨眼睛！少女心爆棚！05Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services06Qwen3.5-Omni与Qwen3.6模型全面解析（含测评/案例/使用教程）07Mac 本地部署 OMLX + 通义千问 Qwen3.5-27B 保姆级教程08UV安装并设置国内源09“wsl --install -d Ubuntu-22.04”下载慢，中国地区离线安装 Ubuntu 22.04 WSL方法（亲测2025年5月6日）10让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南