Android Activity启动流程

发表于 | 分类于

ActivityManagerService和ActivityStack位于同一个进程中，而ApplicationThread和ActivityThread位于另一个进程中。其中，ActivityManagerService是负责管理Activity的生命周期的，ActivityManagerService还借助ActivityStack是来把所有的Activity按照后进先出的顺序放在一个堆栈中；对于每一个应用程序来说，都有一个ActivityThread来表示应用程序的主进程，而每一个ActivityThread都包含有一个ApplicationThread实例，它是一个Binder对象，负责和其它进程进行通信。

sss

我们每次通过Context来启动activity的时候，实际上是通过其实现类ContextImpl来实现的 ContextImpl 中启动activity的代码如下： 

1
2
3
4
5
6
7
@Override
   public void startActivities(Intent[] intents, Bundle options) {
       ...
       mMainThread.getInstrumentation().execStartActivities(
               getOuterContext(), mMainThread.getApplicationThread(), null,
               (Activity) null, intents, options);
   }

这里的mMainThread是一个ActivityThread对象，最终是通过Instrumentation.execStartActivity 方法启动activity的 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        ........

        try {
            // 通过ActivityManagerNative.getDefault()的startActivity来启动activity
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
            // 根据返回的result结果，给用户对应的提示
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
}

看下checkStartActivityResult方法，比较简单，主要是对启动的结果一个反馈 

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
/** @hide */
   public static void checkStartActivityResult(int res, Object intent) {
       if (res >= ActivityManager.START_SUCCESS) {
           return;//如果成功，则直接返回，否则抛出对应的异常
       }

       switch (res) {
           case ActivityManager.START_INTENT_NOT_RESOLVED:
           case ActivityManager.START_CLASS_NOT_FOUND:
               if (intent instanceof Intent && ((Intent)intent).getComponent() != null)
                   throw new ActivityNotFoundException(
                           "Unable to find explicit activity class "
                           + ((Intent)intent).getComponent().toShortString()
                           + "; have you declared this activity in your AndroidManifest.xml?");
               throw new ActivityNotFoundException(
                       "No Activity found to handle " + intent);
           case ActivityManager.START_PERMISSION_DENIED:
               throw new SecurityException("Not allowed to start activity "
                       + intent);
       ...
           default:
               throw new AndroidRuntimeException("Unknown error code "
                       + res + " when starting " + intent);
       }
   }

继续回到之前的ActivityManagerNative.getDefault() 

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
   /**
     * Retrieve the system's default/global activity manager.
     */
    static public IActivityManager getDefault() {
        return gDefault.get();
    }
    
      private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
        protected IActivityManager create() {
            // 获取activityManagerService对应的对象
            IBinder b = ServiceManager.getService("activity");
            if (false) {
                Log.v("ActivityManager", "default service binder = " + b);
            }
            // 返回ActivityManagerService实例
            IActivityManager am = asInterface(b);
            if (false) {
                Log.v("ActivityManager", "default service = " + am);
            }
            return am;
        }
    };
    
    public abstract class Singleton<T> {
    private T mInstance;

    protected abstract T create();

    public final T get() {
        synchronized (this) {
            if (mInstance == null) {
            	// 当通过get()方法获取该实例，会通过其重写的create()方法创建
                mInstance = create();
            }
            return mInstance;
        }
    }
}

以上三个方法均位于ActivityManagerNative类中，通过上面的代码和注释这里会返回一个单例模式的ActivityManagerService服务，也就是说我们最终是通过ActivityManagerService.startActivity 来启动activity的 

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

mActivityStarter是ActivityStarter类的实例，该类的主要用来管理activity的出入栈和切换，看下ActivityStarter.startActivityMayWait方法 

1
2
3
4
5
6
7
8
9
10
11
12
13
final int startActivityMayWait(参数省略.....) {
	ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId);
	ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
     .....
     // 上述省略内容主要从Intent里解析需要启动的Activity的相关信息。如：包名、类名。相关信息存在ResolveInfo类中，通过该类里面得到ActivityInfo对象。

     int res = startActivityLocked(caller, intent, resolvedType, aInfo,
                    voiceSession, voiceInteractor, resultTo, resultWho,
                    requestCode, callingPid, callingUid, callingPackage,
                    realCallingPid, realCallingUid, startFlags, options, ignoreTargetSecurity,
                    componentSpecified, null, container, inTask);
    return res;
}

上面startActivityMayWait方法比较多的判断，主要代码就是我标注出来的那一段，接着又调用了自己内部的ActivityStackSupervisor.startActivityLocked方法

通过传入的caller形参（IApplicationThread类型，从Activity的startActivity函数就开始一个个函数调用传入）得到调用者进程相关信息，保存到callerApp（ProcessRecord类型）变量中，然后创建要启动的Activity相关信息。保存到r（ActivityRecord）变量中。 

1
2
3
4
5
6
7
final int startActivityLocked(参数省略 ...) {
    ....
    err = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
                    true, options, inTask);
    // 这里的err表示当前activity启动的结果
    return err;
}

调用ActivityStarter.startActivityUnchecked方法 

1
2
3
4
5
6
7
8
9
10
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
    IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
    int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask) {
    .......
    // 上面省略的那些代码是对不同情况的一个判断，如果在此处返回，则activity会启动失败,获取Activity的启		动模式、判断要启动的Activity是否在栈顶、得到Activity加载的栈。
   if (mDoResume) {
		mSupervisor.resumeFocusedStackTopActivityLocked();
   }
   targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options);
}

转到了ActivityStackSupervisor.java中的resumeFocusedStackTopActivityLocked函数： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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);
       }
       return false;
   }

接着又转到了ActivityStack.java中的resumeTopActivityUncheckedLocked方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
       if (mStackSupervisor.inResumeTopActivity) {
           // Don't even start recursing.
           return false;
       }

       boolean result = false;
       try {
           // Protect against recursion.
           mStackSupervisor.inResumeTopActivity = true;
           if (mService.mLockScreenShown == ActivityManagerService.LOCK_SCREEN_LEAVING) {
               mService.mLockScreenShown = ActivityManagerService.LOCK_SCREEN_HIDDEN;
               mService.updateSleepIfNeededLocked();
           }
           result = resumeTopActivityInnerLocked(prev, options);
       } finally {
           mStackSupervisor.inResumeTopActivity = false;
       }
       return result;
   }

又进入resumeTopActivityInnerLocked：

1
2
3
4
5
  private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
	startPausingLocked(userLeaving, false, true, dontWaitForPause);
	...
	mStackSupervisor.startSpecificActivityLocked(next, true, true);
}

startPausingLocked应该是暂停启动Activity的那个Activity，然后又回到ActivityStackSupervisor中的startSpecificActivityLocked函数： 

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
void startSpecificActivityLocked(ActivityRecord r,boolean andResume, boolean checkConfig) {
        // Is this activity's application already running?
        ProcessRecord app = mService.getProcessRecordLocked(r.processName,
                r.info.applicationInfo.uid, true);

        r.task.stack.setLaunchTime(r);

        if (app != null && app.thread != null) {
            try {
                if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
                        || !"android".equals(r.info.packageName)) {
                    // Don't add this if it is a platform component that is marked
                    // to run in multiple processes, because this is actually
                    // part of the framework so doesn't make sense to track as a
                    // separate apk in the process.
                    app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
                            mService.mProcessStats);
                }
                realStartActivityLocked(r, app, andResume, checkConfig);
                return;
            } catch (RemoteException e) {
                Slog.w(TAG, "Exception when starting activity "
                        + r.intent.getComponent().flattenToShortString(), e);
            }

            // If a dead object exception was thrown -- fall through to
            // restart the application.
        }

        mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
                "activity", r.intent.getComponent(), false, false, true);
    }

这里因为启动的Activity不是应用的第一个Activity所以上面app的信息不为null，进入realStartActivityLocked中： 

1
2
3
4
5
6
7
8
9
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(task.mOverrideConfig), r.compat, r.launchedFromPackage,
        task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
        newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);
}

这里的app.thread是远程binder代理，它是在ActivityManagerNative中的onTransact中初始化： 

1
2
3
4
5
6
7
8
9
10
11
@Override
   public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
           throws RemoteException {
       switch (code) {
       case START_ACTIVITY_TRANSACTION:
       {
           data.enforceInterface(IActivityManager.descriptor);
           IBinder b = data.readStrongBinder();
           IApplicationThread app = ApplicationThreadNative.asInterface(b);
       }
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * Cast a Binder object into an application thread interface, generating
 * a proxy if needed.
 */
static public IApplicationThread asInterface(IBinder obj) {
    if (obj == null) {
        return null;
    }
    IApplicationThread in =
        (IApplicationThread)obj.queryLocalInterface(descriptor);
    if (in != null) {
        return in;
    }

    return new ApplicationThreadProxy(obj);
}

可以看到这个代理是ApplicationThreadProxy类型，调用scheduleLaunchActivity会进入stub实现类（ApplicationThread）里面： 

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
// we use token to identify this activity without having to send the
// activity itself back to the activity manager. (matters more with ipc)
@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);
}
1
2
3
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
    mH.sendMessage(msg);
}

这里的mH是handler类型，发消息让它切换到主线程处理： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private class H extends Handler {
    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, "LAUNCH_ACTIVITY");
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            } break;
            ...
        }
    }
}

进入handleLaunchActivity: 

1
2
3
4
5
6
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
	...
	Activity a = performLaunchActivity(r, customIntent);
	handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
}

进入handleResumeActivity： 

1
2
3
4
5
6
final void handleResumeActivity(IBinder token,boolean clearHide,
boolean isForward, boolean reallyResume, int seq, String reason) { 

    // TODO Push resumeArgs into the activity for consideration
    r = performResumeActivity(token, clearHide, reason);
}

进入performLaunchActivity：

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

        try {
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);
            if (activity != null) {
                Context appContext = createBaseContextForActivity(r, activity);
                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 = null;
                if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
                    window = r.mPendingRemoveWindow;
                    r.mPendingRemoveWindow = null;
                    r.mPendingRemoveWindowManager = null;
                }
                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);

                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);
                    }
                }
            }
            r.paused = true;
            mActivities.put(r.token, r);
        }
        return activity;
    }

终于可以看到这里用Instrumentation创建Activity，接着创建Application、ContextImpl、Configuration等，接着调用Activity的attach函数，将创建的对象关联到Activity。

Activity启动过程