Activity的启动过程

最新推荐文章于 2024-08-20 16:30:17 发布
最新推荐文章于 2024-08-20 16:30:17 发布
阅读量179 收藏
点赞数
分类专栏： android

从Activity的startActivity方法开始的，

@Override
public void startActivity(Intent intent) {
    this.startActivity(intent, null);
}

使用this关键字调用 了startActivity方法的两个参数的重载。如下：

@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
    if (options != null) {
        startActivityForResult(intent, -1, options);
    } else {
        // Note we want to go through this call for compatibility with
        // applications that may have overridden the method.
        startActivityForResult(intent, -1);
    }
}

都会调用startActivityForResult方法。并将intent传进。

public void startActivityForResult(Intent intent, int requestCode) {
    startActivityForResult(intent, requestCode, null);
}

转到了startActivityForResult三个参数的重载方法

public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {
    if (mParent == null) {
        Instrumentation.ActivityResult ar =
            mInstrumentation.execStartActivity(
                this, mMainThread.getApplicationThread(), mToken, this,
                intent, requestCode, options);
        if (ar != null) {
            mMainThread.sendActivityResult(
                mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                ar.getResultData());
        }
        if (requestCode >= 0) {
            // If this start is requesting a result, we can avoid making
            // the activity visible until the result is received.  Setting
            // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
            // activity hidden during this time, to avoid flickering.
            // This can only be done when a result is requested because
            // that guarantees we will get information back when the
            // activity is finished, no matter what happens to it.
            mStartedActivity = true;
        }

        cancelInputsAndStartExitTransition(options);
        // TODO Consider clearing/flushing other event sources and events for child windows.
    } else {
        if (options != null) {
            mParent.startActivityFromChild(this, intent, requestCode, options);
        } else {

        //代码省略
        }
    }
}

execStartActivity方法的第二个参mMainThread.getApplicationThread()。是一个ApplicationThread对象。ApplicationThread继承自ApplicationThreadNative，而ApplicationThreadNative继承自Binder并实现了IApplicationThread接口。也就是说ApplicationThread是一个Binder，而且是IApplicationThread的实现类。

那现在跟进看看Instrumentation的execStartActivity方法内部实现，

public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
    IApplicationThread whoThread = (IApplicationThread) contextThread;
    Uri referrer = target != null ? target.onProvideReferrer() : null;

    //代码省略

    try {
        intent.migrateExtraStreamToClipData();
        intent.prepareToLeaveProcess();
        int result = ActivityManagerNative.getDefault()
            .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;
}

从execStartActivity方法的参数列表也可以看出，刚才传进的ApplicationThread是一个Binder。
那么现在分析下execStartActivity方法的内部实现，找到了startActivity的字眼了，在try/catch代码块，这个从抛出的异常RemoteException，也可以推断是一个跨进程操作了。先不管。从try/catch代码块中可以看到ActivityManagerNative.getDefault()调用了startActivity的方法去启动Activity，

ActivityManagerNative是一个抽象类来的，继承自Binder并实现了IActivityManager接口。而ActivirtManagerService是继承自ActivityManagerNative这个抽象类的，也就是说ActivirtManagerService是IActivityManager的实现类。
那么ActivityManagerNative.getDefault()返回的是一个ActivirtManagerService，简称AMS。

经过一系列的方法调用，可以看到调用了realStartActivityLocked方法，这个方法已经开始将Activity的启动过程往AvtivityThread靠近了。那继续跟进realStartActivityLocked方法。

final boolean realStartActivityLocked(ActivityRecord r,
        ProcessRecord app, boolean andResume, boolean checkConfig)
        throws RemoteException {

       //代码省略

          app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
                new Configuration(stack.mOverrideConfig), r.compat, r.launchedFromPackage,
                task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
                newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);

//代码省略

        return true;
}

app.thread 是一个IApplicationThread类型的实现类，那么从开始的分析可以知道就是ApplicationThread。ApplicationThread还是ActivityThread的内部类，我们现在已经回到了主线程。

@Override
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
        ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
        CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
        int procState, Bundle state, PersistableBundle persistentState,
        List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
        boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {

    updateProcessState(procState, false);

    ActivityClientRecord r = new ActivityClientRecord();

    r.token = token;
    r.ident = ident;
    r.intent = intent;
    r.referrer = referrer;
    r.voiceInteractor = voiceInteractor;
    r.activityInfo = info;
    r.compatInfo = compatInfo;
    r.state = state;
    r.persistentState = persistentState;

    r.pendingResults = pendingResults;
    r.pendingIntents = pendingNewIntents;

    r.startsNotResumed = notResumed;
    r.isForward = isForward;

    r.profilerInfo = profilerInfo;

    r.overrideConfig = overrideConfig;
    updatePendingConfiguration(curConfig);

    sendMessage(H.LAUNCH_ACTIVITY, r);
}

ScheduleLaunchActivity的逻辑比较简单，封装了一些Activity组件信心，然后发送一个消息到ActivityThread。那么我们找到LAUNCH_ACTIVITY这个消息即可。

public void handleMessage(Message msg) {
    if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
    switch (msg.what) {
        case LAUNCH_ACTIVITY: {
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
            final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

            r.packageInfo = getPackageInfoNoCheck(
                    r.activityInfo.applicationInfo, r.compatInfo);
            handleLaunchActivity(r, null);
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        } break;

     //代码省略

}
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {

    //代码省略

    // Initialize before creating the activity
    WindowManagerGlobal.initialize();

    Activity a = performLaunchActivity(r, customIntent);

    if (a != null) {
        r.createdConfig = new Configuration(mConfiguration);
        Bundle oldState = r.state;
        handleResumeActivity(r.token, false, r.isForward,
                !r.activity.mFinished && !r.startsNotResumed);

        //代码省略

    }
}

那么我们就看到核心的performLaunchActivity方法：

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");

    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);
    }

    if (r.activityInfo.targetActivity != null) {
        component = new ComponentName(r.activityInfo.packageName,
                r.activityInfo.targetActivity);
    }

    Activity activity = null;
    try {
        java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
        activity = mInstrumentation.newActivity(
                cl, component.getClassName(), r.intent);
        StrictMode.incrementExpectedActivityCount(activity.getClass());
        r.intent.setExtrasClassLoader(cl);
        r.intent.prepareToEnterProcess();
        if (r.state != null) {
            r.state.setClassLoader(cl);
        }
    } catch (Exception e) {
        if (!mInstrumentation.onException(activity, e)) {
            throw new RuntimeException(
                "Unable to instantiate activity " + component
                + ": " + e.toString(), e);
        }
    }

    try {
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);

        if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
        if (localLOGV) Slog.v(
                TAG, r + ": app=" + app
                + ", appName=" + app.getPackageName()
                + ", pkg=" + r.packageInfo.getPackageName()
                + ", comp=" + r.intent.getComponent().toShortString()
                + ", dir=" + r.packageInfo.getAppDir());

        if (activity != null) {
            Context appContext = createBaseContextForActivity(r, activity);
            CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
            Configuration config = new Configuration(mCompatConfiguration);
            if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
                    + r.activityInfo.name + " with config " + config);
            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);

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

            activity.mCalled = false;
            if (r.isPersistable()) {
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }
            if (!activity.mCalled) {
                throw new SuperNotCalledException(
                    "Activity " + r.intent.getComponent().toShortString() +
                    " did not call through to super.onCreate()");
            }
            r.activity = activity;
            r.stopped = true;
            if (!r.activity.mFinished) {
                activity.performStart();
                r.stopped = false;
            }
            if (!r.activity.mFinished) {
                if (r.isPersistable()) {
                    if (r.state != null || r.persistentState != null) {
                        mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                                r.persistentState);
                    }
                } else if (r.state != null) {
                    mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
                }
            }
            if (!r.activity.mFinished) {
                activity.mCalled = false;
                if (r.isPersistable()) {
                    mInstrumentation.callActivityOnPostCreate(activity, r.state,
                            r.persistentState);
                } else {
                    mInstrumentation.callActivityOnPostCreate(activity, r.state);
                }
                if (!activity.mCalled) {
                    throw new SuperNotCalledException(
                        "Activity " + r.intent.getComponent().toShortString() +
                        " did not call through to super.onPostCreate()");
                }
            }
        }
        r.paused = true;

        mActivities.put(r.token, r);

    } catch (SuperNotCalledException e) {
        throw e;

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

    return activity;
}

首先从ActivityClientRecord中获取待启动的Activity的组件信息，ActivityClientRecord里面是封装了很多东西的。如果r.packageInfo==null，调用getPackageInfo方法获取到LoadedApk实例并赋值给r.packageInfo

通过LoadedApk获取到一个类加载器，调用Instrumentation的newActivity方法通过这个类加载器创建了一个Activity对象 ，

接着调用LoadedApk的makeApplication方法创建Application对象，可以看到Application是唯一的。创建Application后，Instrumentation会调用callApplicationOnCreate去回调Application的onCreate方法。

再接着调用createBaseContextForActivity方法，创建了一个Context的实现类ContextImpl的对象

最后Activity调用attach与Application，ContextImpl等关联起来。

也调用了Instrumentation的callActivityOnCreate方法去回调了Activity的onCreate方法，至此，Activity终于诞生了

出处：参考文章

清华落榜生
关注
专栏目录
Android：Context完全解析，你所不知道的Context的各种细节
微不足道的博客
12-17 2000
Context的各种细节
Android Activity启动过程分析
sd_zhuzhipeng的专栏
08-06 3022
当我们在一个Activity中（或通过Context对象），调用startActivity()方法来启动另一个Activity的工程中发发生了什么呢？这就是本文想跟大家分享的内容，我们一起通过源码的方式来看下Activity的启动过程（本文是基于Android Q源码）。  启动Activity的流程大体分为两步：找到要启动的Activity；然后启动它。（虽说有点像如何把大象装进冰箱，但也确实是那么回事，只不过每个步骤有更多细节） 找到Activity  要想启动一个Activity，系统先要找到这个.
Activity启动流程
k663514387的博客
07-14 1316
Activity启动流程详解
Android Activity启动流程(Android 13)
最新发布
xiangxiongfly
08-20 1149
文章目录Android Activity启动流程(Android 13)概述执行流程前提流程分析Activity#startActivity()Activity#startActivityForResult()Instrumentation#execStartActivity()ActivityTaskManager#getService()ActivityTaskManagerService#startActivity()ActivityTaskManagerService#startActivityAs
Activity启动过程
06-20
Activity启动过程
Android应用程序的Activity启动过程简要介绍和学习计划.doc
07-13
7. **异常处理**：学习如何处理Activity启动过程中的异常，例如没有找到匹配的Activity或权限问题。 8. **实践项目**：通过编写小型应用或修改现有项目，实践Activity的启动和管理。 通过以上学习计划，你可以逐步...
Activity 启动过程源码+分析过程
10-16
理解Activity的启动过程对于优化应用性能、解决兼容性问题以及深入学习Android系统至关重要。本篇文章将详细解析Activity的启动过程源码，并进行深度分析。 1. **Activity启动流程概述** Activity的启动流程主要...
根Activity启动过程
weixin_34212762的博客
12-25 123
--摘自《Android进阶解密》 根Activity启动过程中会涉及4个进程，分别是Zygote进程、Launcher进程、AMS所在进程（SystemServer进程）、应用程序进程，关系图如下 其中步骤2采用的是Socket通信，步骤1和4采用的是Binder通信 如果是普通Activity启动过程会涉及两个进程：AMS所在进程和应用程序进程 启动过程 第一步：Launcher请求AMS...
Activity启动过程（一）
omyrobin的专栏
12-26 387
Launcher启动Acivity（未启动Activity所在进程）public abstract class LauncherActivity extends ListActivity { @Override protected void onListItemClick(ListView l, View v, int position, long id) { Int
Activity的启动过程(1)
无问西东的博客
11-14 610
以下源码采用api19 Activity的启动是受AMS（ActivityMessageService），但是直观来讲，很多童鞋并不熟悉AMS，反而对ActivityThread更加熟悉；其实我们的android系统很像一个BS的架构，Liunx驱动以及底层是服务端，应用层是客户端；服务端和客户端通过Binder来通信； 今天我先讲讲客户端，从ActivityThread讲起，...
Android Activity启动过程解析与学习规划
"这篇文档是关于Android应用程序中Activity启动过程的简要介绍，重点讨论了Activity作为核心组件的角色，以及如何通过显式和隐式方式启动Activity。文章以一个具体的例子来阐述启动流程，并提到了相关学习计划。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值