Android源码分析——Activity启动与生命周期

发表于 | 分类于 | | 阅读次数:
通过分析源码，了解AstartActivity()方法背后的逻辑，以及生命周期是如何执行的

Activity启动流程

就拿最简单的启动方式，即startActivity(Intent)来看，首先是在Activity.java中：

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

调用重载的startActivity()方法，多传入一个空的bundle参数:

1
2
3
4
5
6
7
8
9
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);
        }
    }

因为bunlde为null，所以走下面这个路径：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
           @Nullable Bundle options) {
       if (mParent == null) {
           options = transferSpringboardActivityOptions(options);
           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) {
               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 {
               // Note we want to go through this method for compatibility with
               // existing applications that may have overridden it.
               mParent.startActivityFromChild(this, intent, requestCode);
           }
       }
   }

这里有个疑问，mParent是何用？在网上查阅资料后得知，这个东西是ActivityGroup的遗物，一般Activity是没有的，所以这里会走if这条路。那么可以看到启动Activity时主要在这里：

1
2
3
4
5
6
7
8
9
10
11
12
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) {
      mStartedActivity = true;
  }

先调用mInstrumentation的execStartActivity()方法，启动Activity，启动完毕之后然后拿到返回的启动结果作为一个ActivityRersult，有了这个result就可以做ActivityResult()。那么首先来看一下execStartActivity()方法是怎么执行的：
在Instrumentation.java类中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
            //先获取一个IApplicationThread引用
                IApplicationThread whoThread = (IApplicationThread) contextThread;
        Uri referrer = target != null ? target.onProvideReferrer() : null;
        if (referrer != null) {
            intent.putExtra(Intent.EXTRA_REFERRER, referrer);
        }
        //这里大概时候做一重过滤，如果Activity实例已经存在，则不启动？
        if (mActivityMonitors != null) {
            synchronized (mSync) {
                final int N = mActivityMonitors.size();
                for (int i=0; i<N; i++) {
                    final ActivityMonitor am = mActivityMonitors.get(i);
                    ActivityResult result = null;
                    if (am.ignoreMatchingSpecificIntents()) {
                        result = am.onStartActivity(intent);
                    }
                    if (result != null) {
                        am.mHits++;
                        return result;
                    } else if (am.match(who, null, intent)) {
                        am.mHits++;
                        if (am.isBlocking()) {
                            return requestCode >= 0 ? am.getResult() : null;
                        }
                        break;
                    }
                }
            }
        }
        try {
        //真正的启动逻辑
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess(who);
            //先通过ActivityManager获取一个ActivityManagerService引用，然后具体调用的是AMS的startActivity()方法
            int result = ActivityManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
            //调用之后，检测一下启动的Activity是都合理
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }

AMS即ActivityManagerService，这里是用过Binder机制远程调用了他。现在看ActivityManagerService.java的startActivity()方法:

1
2
3
4
5
6
7
8
9

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

调用了startActivityAsUser()方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Override
 public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
         Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
         int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
     enforceNotIsolatedCaller("startActivity");
     userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
             userId, false, ALLOW_FULL_ONLY, "startActivity", null);
     // TODO: Switch to user app stacks here.
     return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
             resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
             profilerInfo, null, null, bOptions, false, userId, null, null,
             "startActivityAsUser");
 }

在获取了一个userId之后，调用了mActivityStarter的mActivityStarter.startActivityMayWait()方法。这个mActivityStarter是一个ActivityStarter类的对象，这个类主要用来做Activity启动之前的准备工作，比如intent和flags的逻辑，管理stack和taskrecord等。接下来进入了ActivityStarter.java中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
   final int startActivityMayWait(IApplicationThread caller, int callingUid,
           String callingPackage, Intent intent, String resolvedType,
           IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
           IBinder resultTo, String resultWho, int requestCode, int startFlags,
           ProfilerInfo profilerInfo, WaitResult outResult,
           Configuration globalConfig, Bundle bOptions, boolean ignoreTargetSecurity, int userId,
           IActivityContainer iContainer, TaskRecord inTask, String reason) {
       // Refuse possible leaked file descriptors
       if (intent != null && intent.hasFileDescriptors()) {
           throw new IllegalArgumentException("File descriptors passed in Intent");
       }
       //处理intent
       SResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId);
       if (rInfo == null) {
           UserInfo userInfo = mSupervisor.getUserInfo(userId);
           if (userInfo != null && userInfo.isManagedProfile()) {
               // Special case for managed profiles, if attempting to launch non-cryto aware
               // app in a locked managed profile from an unlocked parent allow it to resolve
               // as user will be sent via confirm credentials to unlock the profile.
               UserManager userManager = UserManager.get(mService.mContext);
               boolean profileLockedAndParentUnlockingOrUnlocked = false;
               long token = Binder.clearCallingIdentity();
               try {
                   UserInfo parent = userManager.getProfileParent(userId);
                   profileLockedAndParentUnlockingOrUnlocked = (parent != null)
                           && userManager.isUserUnlockingOrUnlocked(parent.id)
                           && !userManager.isUserUnlockingOrUnlocked(userId);
               } finally {
                   Binder.restoreCallingIdentity(token);
               }
               if (profileLockedAndParentUnlockingOrUnlocked) {
                   rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId,
                           PackageManager.MATCH_DIRECT_BOOT_AWARE
                                   | PackageManager.MATCH_DIRECT_BOOT_UNAWARE);
               }
           }
       }
       // Collect information about the target of the Intent.
       //处理Activity，找到相对应的Activity组件，并且保存Intent
       ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
       //……………………
       //这里处理Activity任务栈相关内容
           final ActivityRecord[] outRecord = new ActivityRecord[1];
           int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType,
                   aInfo, rInfo, voiceSession, voiceInteractor,
                   resultTo, resultWho, requestCode, callingPid,
                   callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
                   options, ignoreTargetSecurity, componentSpecified, outRecord, container,
                   inTask, reason);
           mSupervisor.mActivityMetricsLogger.notifyActivityLaunched(res, outRecord[0]);
//………………
   }

在这面首先获取了传入的Intent等信息，之后交给startActivityLocked()方法来创建ActivityRecord，这其中就包含着Activity的重要信息。在这一方法中，层层调用之后来到了这里：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
        ActivityRecord[] outActivity) {
    int result = START_CANCELED;
    try {
        mService.mWindowManager.deferSurfaceLayout();
        //这里调用了startActivityUnchecked()方法，是根据启动的flag信息，设置taskRecord.
        result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                startFlags, doResume, options, inTask, outActivity);
    } finally {
        // If we are not able to proceed, disassociate the activity from the task. 
        //…………
    }
}

在调用startActivityUnchecked()时，最终走到了ActivityStackSupervisor.java中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

boolean resumeFocusedStackTopActivityLocked() {
    return resumeFocusedStackTopActivityLocked(null, null, null);
}

boolean resumeFocusedStackTopActivityLocked(
        ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
    if (targetStack != null && isFocusedStack(targetStack)) {
        return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
    }
    final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
    if (r == null || r.state != RESUMED) {
        mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
    } else if (r.state == RESUMED) {
        // Kick off any lingering app transitions form the MoveTaskToFront operation.
        mFocusedStack.executeAppTransition(targetOptions);
    }
    return false;
}

ActivityStackSupervisor类与ActivityStack类配合使用. ActivityStackSupervisor负责管理Task和Stack, 而ActivityStack负责管理在Stack和Task中的Activity。

这里会调用activityStack的resumeTopActivityUncheckedLocked()方法，然后开始一个调用链：
ActivityStack的resumeTopActivityInnerLocked() ->
ActivityStackSupervisor的startSpecificActivityLocked() -> ActivityStackSupervisor的realStartActivityLocked()

到这里，正如方法名所描述的那样，真正开始启动Activity了：

1
2
3
4
5
6
7
8
9
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                    System.identityHashCode(r), r.info,
                    // TODO: Have this take the merged configuration instead of separate global and
                    // override configs.
                    mergedConfiguration.getGlobalConfiguration(),
                    mergedConfiguration.getOverrideConfiguration(), r.compat,
                    r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
                    r.persistentState, results, newIntents, !andResume,
                    mService.isNextTransitionForward(), profilerInfo);

最后由ActivityThread中的ApplicationThread调用scheduleLaunchActivity完成Activity的真正启动。这里的thread是IApplicationThread接口，该接口继承了IInterface接口，实现方法asBinder()方法作为binder通信。

所以最终的启动就到了ActivityThrad.java中，怎么，熟不熟悉？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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);
 }

很显然，启动Activity是要先创建一个ActivityClientRecord对象，然后通过Handler消息机制来告诉我们的主线程来启动，直接来看H.LAUNCH_ACTIVITY这条消息的处理：

1
2
3
4
5
6
7
8
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, "LAUNCH_ACTIVITY");
              Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

调用了hanlleLaunchActivity()方法用来启动Actiivity：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
        // If we are getting ready to gc after going to the background, well
        // we are back active so skip it.
        unscheduleGcIdler();
        mSomeActivitiesChanged = true;

        if (r.profilerInfo != null) {
            mProfiler.setProfiler(r.profilerInfo);
            mProfiler.startProfiling();
        }

        // Make sure we are running with the most recent config.
        handleConfigurationChanged(null, null);

        if (localLOGV) Slog.v(
            TAG, "Handling launch of " + r);

        //先初始化
        // Initialize before creating the activity
        WindowManagerGlobal.initialize();
        //创建一个Activity实例并返回，在这里面调用了新Activity的onCreate()
        Activity a = performLaunchActivity(r, customIntent);

        if (a != null) {
            r.createdConfig = new Configuration(mConfiguration);
            reportSizeConfigurations(r);
            Bundle oldState = r.state;
            //执行创建完成的新Activity的onResume()方法
            handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);

            if (!r.activity.mFinished && r.startsNotResumed) {
                // The activity manager actually wants this one to start out paused, because it
                // needs to be visible but isn't in the foreground. We accomplish this by going
                // through the normal startup (because activities expect to go through onResume()
                // the first time they run, before their window is displayed), and then pausing it.
                // However, in this case we do -not- need to do the full pause cycle (of freezing
                // and such) because the activity manager assumes it can just retain the current
                // state it has.
                //旧的Activity的onPause()方法
                performPauseActivityIfNeeded(r, reason);

                // We need to keep around the original state, in case we need to be created again.
                // But we only do this for pre-Honeycomb apps, which always save their state when
                // pausing, so we can not have them save their state when restarting from a paused
                // state. For HC and later, we want to (and can) let the state be saved as the
                // normal part of stopping the activity.
                if (r.isPreHoneycomb()) {
                    r.state = oldState;
                }
            }
        } else {
            // If there was an error, for any reason, tell the activity manager to stop us.
            try {
                ActivityManager.getService()
                    .finishActivity(r.token, Activity.RESULT_CANCELED, null,
                            Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
            } catch (RemoteException ex) {
                throw ex.rethrowFromSystemServer();
            }
        }
    }

其中最主要的就是performLaunchActivity()方法了，在这里创建了最终的Activity实例，来看一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
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);
    }

    //创建的新Activity所需的一些参数
    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相对应的Context
    ContextImpl appContext = createBaseContextForActivity(r);
    //这里终于开始创建Activity了！
    Activity activity = null;
    try {
        //通过要创建的Activity的类加载器来创建一个对象
        java.lang.ClassLoader cl = appContext.getClassLoader();
        //就是这儿，创建了一个Activity
        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) {
            CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
            Configuration config = new Configuration(mCompatConfiguration);
            if (r.overrideConfig != null) {
                config.updateFrom(r.overrideConfig);
            }
            if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
                    + r.activityInfo.name + " with config " + config);
            //创建一个Window
            Window window = null;
            if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
                window = r.mPendingRemoveWindow;
                r.mPendingRemoveWindow = null;
                r.mPendingRemoveWindowManager = null;
            }
            appContext.setOuterContext(activity);
            //每一个Activity在这里和Window作绑定
            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);

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

            activity.mCalled = false;
            //这儿就是Activity的第一个生命周期 onCreate()的执行！
            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的生命周期onStart()!
                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;
}

到此为止，startActivity()的所有流程就走了一遍