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

目录

    • 概述
    • 阶段一: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回调应用进程
相关推荐
FungLeo4 小时前
FengCMS · PHP+MySQL 升级实录 · 危险默认值之殇:root/123456、认证码 8888 写进配置加载器
android·mysql·php·安全加固·fengcms
yz_aiks4 小时前
Termux 使用教程:把安卓手机变成随身 Linux(装 Python、SSH 远程、跑自动化脚本)
android·linux·python·智能手机·ssh·termux
booboosui12 小时前
编号没变,消息还是来了:Mac 端通知读取漏第二条的原因
android
雨白1 天前
单例设计模式:从 Java/Kotlin 实现到 Android 实战
android
hai_android1 天前
一行 asLiveData,背后是一座生命周期的桥
android·java·kotlin
阿杰m1 天前
Android源码第二十三章:Telephony、RIL 与 IMS——来电怎么到应用?
android
booboosui1 天前
没人认领 .md:安卓把报告交给了音乐播放器打开
android
用户60709759149062 天前
AOSP 14 OTA 升级指导(四):update_engine 内部机制——Action 流水线与写盘
android
恋猫de小郭2 天前
Jetpack Compose 1.13 发布,憋了这么久终有交代了
android·前端·flutter
JMchen1232 天前
【Android 性能优化实战 60 讲】12 异步 Inflate 实战与痛击:源码拆解原生瓶颈,手写增强版布局预加载框架
android·性能优化·实战·启动优化·异步inflate·x2c