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

概述

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

阶段一：Launcher发起启动请求

1.1 Launcher点击事件处理

源码位置： packages/apps/Launcher3/src/com/android/launcher3/Launcher.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

// 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

// 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

// 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

// 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

// 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

// 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

// 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

// 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

// 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

// 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消息

// 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

// 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

// 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处理启动

// 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和界面显示

// 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

// 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 完整的绘制流程

// 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回调应用进程