神刀安全网

[Android四大组件]Activity启动过程源码分析

Activity 应该是大家再熟悉不过的了。从刚开始搭建Android开发环境,跑的第一个例子 Hello World 就用到了 Activity 。再后来会接触到 Activity 的生命周期,想当初学姐这几个生命周期顺序经常会记错:broken_heart:,再后来就是广泛使用 FragmentActivityFragment 了。

平常开发中以上这些资料Baidu一大堆,还轮不到Google劳神。然而熟练运用这些顶多也就是一个Coder搬砖熟练工而已,算不上Engineer吧~

本文从就从Activity的源码角度分析其启动过程。

1.Activity几个重要类:

(1)Activity

An activity is a single, focused thing that the user can do. Almost all activities interact with the user, so the Activity class takes care of creating a window for you in which you can place your UI with {@link #setContentView}.

Activity是一件单一的、需要注意力的事情。通常用来和用户打交道,为用户创建一个窗口来放置UI。

(2)Instrumentation

用于执行具体操作的类,辅助Activity的监控和测试。

(3)ActivityManagerNative、ActivityManagerProxy、IActivityManager

我理解是,提供给用户进程,用来与system_process进程的ActivityManagerService打交道的一些类。

(4)ApplicationThread、ApplicationThreadNative、IApplicationThread

我理解是,ActivityManagerService用来与用户进程打交道的一些类,最终会回调到用户进程。

2.关系梳理:

[Android四大组件]Activity启动过程源码分析

ActivityManager 是用户进程中对应用层开放的类,应用层要完成某项操作,最终都是由system_process进程的 ActivityManagerService 来实现。即 ActivityManager 需要和 ActivityManagerService 进行跨进程通信。Android中IPC通过 Binder 机制实现。 ActivityManagerService 继承于 ActivityManagerNative ,而 ActivityManagerNative 实现 IBinderIActivityManager 接口,一方面具有 IActivityManager 的功能,另一方面作为一个 Binder 实例可以进行IPC操作。 ActivityManagerProxy 的作用是作为 ActivityManagerService 的一个代理,将 ActivityManagerActivityManagerService 解耦合,它也继承 IActivityManager ,这就是典型的代理模式的用法,代理者和被代理者继承相同的接口完成操作,从而client端不知道具体操作是由代理者还是被代理者完成。

Activity 启动过程中, startActivity 操作是先通过 ActivityManagerNative 去拿到 ActivityManagerService 的实例,然后将 ActivityManagerService 实例用 ActivityManagerProxy 进行包装,提供给调用者,真正执行 startActivity 操作的还是 ActivityManagerService ,即mRemote。然后用户进程通过 Binder 方式向 ActivityManagerService 请求Launch操作, ActivityManagerService 调用远端的 startActivity() 执行操作,最终会调到 ApplicationThreadscheduleLaunchActivity() ,然后回传到应用层,继而启动 ActivityonCreate()onStart()onResume() 等方法。 ApplicationThreadActivityThread 的内部类。

下图是 ApplicationThread 的关系图:

[Android四大组件]Activity启动过程源码分析

3.调用流程:

(1)执行 ActivitystartActivity() 方法

@Override public void startActivity(Intent intent) {     this.startActivity(intent, null); }  @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);     } }  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 {             // Note we want to go through this method for compatibility with             // existing applications that may have overridden it.             mParent.startActivityFromChild(this, intent, requestCode);         }     } } 

当我们从Activity A启动Activity B时,调用A的startActivity ,最终走到startActivityForResult。若A没有父Activity,则执行mInstrumentation.execStartActivity()得到一个结果,然后通过调用mMainThread.sendActivityResult()将返回结果回传给A,最终会根据requestCode的情况可能走到A的onActivityResult();若A是ActivityGroup中的子Activity,则调用mParent.startActivityFromChild(),逻辑和普通情况一样,只不过在父Activity中调用。

(2)执行 InstrumentationexecStartActivity() 方法

 * @param who The Context from which the activity is being started.  * @param contextThread The main thread of the Context from which the activity  *                      is being started.  * @param token Internal token identifying to the system who is starting   *              the activity; may be null.  * @param target Which activity is performing the start (and thus receiving   *               any result); may be null if this call is not being made  *               from an activity.  * @param intent The actual Intent to start.  * @param requestCode Identifier for this request's result; less than zero   *                    if the caller is not expecting a result.  * @param options Addition options.  *  * @return To force the return of a particular result, return an   *         ActivityResult object containing the desired data; otherwise  *         return null.  The default implementation always returns null.  */ 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;     if (referrer != null) {         intent.putExtra(Intent.EXTRA_REFERRER, referrer);     }     if (mActivityMonitors != null) {         synchronized (mSync) {             final int N = mActivityMonitors.size();             for (int i=0; i<N; i++) {                 final ActivityMonitor am = mActivityMonitors.get(i);                 if (am.match(who, null, intent)) {                     am.mHits++;                     if (am.isBlocking()) {                         return requestCode >= 0 ? am.getResult() : null;                     }                     break;                 }             }         }     }     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; } 

最终调用的是ActivityManagerNative.getDefault().startActivity()。下面继续看ActivityManagerNative。

(3)执行 ActivityManagerProxystartActivity() 方法

static public IActivityManager getDefault() {     return gDefault.get(); }  private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {     protected IActivityManager create() {         IBinder b = ServiceManager.getService("activity");         if (false) {             Log.v("ActivityManager", "default service binder = " + b);         }         IActivityManager am = asInterface(b);         if (false) {             Log.v("ActivityManager", "default service = " + am);         }         return am;     } };  /**  * Cast a Binder object into an activity manager interface, generating  * a proxy if needed.  */ static public IActivityManager asInterface(IBinder obj) {     if (obj == null) {         return null;     }     IActivityManager in =         (IActivityManager)obj.queryLocalInterface(descriptor);     if (in != null) {         return in;     }      return new ActivityManagerProxy(obj); }  public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,         String resolvedType, IBinder resultTo, String resultWho, int requestCode,         int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {     Parcel data = Parcel.obtain();     Parcel reply = Parcel.obtain();     data.writeInterfaceToken(IActivityManager.descriptor);     data.writeStrongBinder(caller != null ? caller.asBinder() : null);     data.writeString(callingPackage);     intent.writeToParcel(data, 0);     data.writeString(resolvedType);     data.writeStrongBinder(resultTo);     data.writeString(resultWho);     data.writeInt(requestCode);     data.writeInt(startFlags);     if (profilerInfo != null) {         data.writeInt(1);         profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);     } else {         data.writeInt(0);     }     if (options != null) {         data.writeInt(1);         options.writeToParcel(data, 0);     } else {         data.writeInt(0);     }     mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);     reply.readException();     int result = reply.readInt();     reply.recycle();     data.recycle();     return result; }  @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);         String callingPackage = data.readString();         Intent intent = Intent.CREATOR.createFromParcel(data);         String resolvedType = data.readString();         IBinder resultTo = data.readStrongBinder();         String resultWho = data.readString();         int requestCode = data.readInt();         int startFlags = data.readInt();         ProfilerInfo profilerInfo = data.readInt() != 0                 ? ProfilerInfo.CREATOR.createFromParcel(data) : null;         Bundle options = data.readInt() != 0                 ? Bundle.CREATOR.createFromParcel(data) : null;         int result = startActivity(app, callingPackage, intent, resolvedType,                 resultTo, resultWho, requestCode, startFlags, profilerInfo, options);         reply.writeNoException();         reply.writeInt(result);         return true;     }          ... } 

由以上代码可知,ActivityManagerNative.getDefault().startActivity()最终会调用ActivityManagerProxy的startActivity()。然后通过Binder进程间通信机制,发起START_ACTIVITY_TRANSACTION事务,并将Intent等信息序列化传给远程服务ActivityManagerService。远程服务接收到消息后,将Binder传过来的数据反序列化,并执行相关Activity启动操作。

(4)执行 ActivityManagerServicestartActivity 方法

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

ActivityManagerService的startActivity启动过程又转移到mStackSupervisor.startActivityMayWait函数了。而mStackSupervisor是ActivityStackSupervisor类的对象。ActivityStackSupervisor的startActivityMayWait函数源码较长,简单总结起来流程如下:

startActivityMayWait()-&gt;startActivityLocked()-&gt;startActivityUncheckedLocked()-&gt;startSpecificActivityLocked()-&gt;realStartActivityLocked()

在realStartActivityLocked()方法里又调用了如下代码:

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

(5)执行 ApplicationThreadNativescheduleLaunchActivity() 方法

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) throws RemoteException {     Parcel data = Parcel.obtain();     data.writeInterfaceToken(IApplicationThread.descriptor);     intent.writeToParcel(data, 0);     data.writeStrongBinder(token);     data.writeInt(ident);     info.writeToParcel(data, 0);     curConfig.writeToParcel(data, 0);     if (overrideConfig != null) {         data.writeInt(1);         overrideConfig.writeToParcel(data, 0);     } else {         data.writeInt(0);     }     compatInfo.writeToParcel(data, 0);     data.writeString(referrer);     data.writeStrongBinder(voiceInteractor != null ? voiceInteractor.asBinder() : null);     data.writeInt(procState);     data.writeBundle(state);     data.writePersistableBundle(persistentState);     data.writeTypedList(pendingResults);     data.writeTypedList(pendingNewIntents);     data.writeInt(notResumed ? 1 : 0);     data.writeInt(isForward ? 1 : 0);     if (profilerInfo != null) {         data.writeInt(1);         profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);     } else {         data.writeInt(0);     }     mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,             IBinder.FLAG_ONEWAY);     data.recycle(); }  @Override public boolean onTransact(int code, Parcel data, Parcel reply, int flags)         throws RemoteException {     switch (code) {     case SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION:     {         data.enforceInterface(IApplicationThread.descriptor);         Intent intent = Intent.CREATOR.createFromParcel(data);         IBinder b = data.readStrongBinder();         int ident = data.readInt();         ActivityInfo info = ActivityInfo.CREATOR.createFromParcel(data);         Configuration curConfig = Configuration.CREATOR.createFromParcel(data);         Configuration overrideConfig = null;         if (data.readInt() != 0) {             overrideConfig = Configuration.CREATOR.createFromParcel(data);         }         CompatibilityInfo compatInfo = CompatibilityInfo.CREATOR.createFromParcel(data);         String referrer = data.readString();         IVoiceInteractor voiceInteractor = IVoiceInteractor.Stub.asInterface(                 data.readStrongBinder());         int procState = data.readInt();         Bundle state = data.readBundle();         PersistableBundle persistentState = data.readPersistableBundle();         List<ResultInfo> ri = data.createTypedArrayList(ResultInfo.CREATOR);         List<ReferrerIntent> pi = data.createTypedArrayList(ReferrerIntent.CREATOR);         boolean notResumed = data.readInt() != 0;         boolean isForward = data.readInt() != 0;         ProfilerInfo profilerInfo = data.readInt() != 0                 ? ProfilerInfo.CREATOR.createFromParcel(data) : null;         scheduleLaunchActivity(intent, b, ident, info, curConfig, overrideConfig, compatInfo,                 referrer, voiceInteractor, procState, state, persistentState, ri, pi,                 notResumed, isForward, profilerInfo);         return true;     }          ...     } } 

这一步我的理解是,远端服务ActivityManagerService会告诉ApplicationThreadNative,我要启动Activity了,你帮我启动一下。然后ApplicationThreadNative会调用scheduleLaunchActivity()方法,这一步也是通过Binder进程间通信机制向远端服务发送一个SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION事务,远端服务收到之后最终会回调到ApplicationThread的scheduleLaunchActivity()方法。

(6)执行 ApplicationThreadscheduleLaunchActivity() 方法。

@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); }  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);                 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);             }             break;             ...         }    } }  private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {     // 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 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);          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.             try {                 r.activity.mCalled = false;                 mInstrumentation.callActivityOnPause(r.activity);                 // 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;                 }                 if (!r.activity.mCalled) {                     throw new SuperNotCalledException(                         "Activity " + r.intent.getComponent().toShortString() +                         " did not call through to super.onPause()");                 }              } catch (SuperNotCalledException e) {                 throw e;              } catch (Exception e) {                 if (!mInstrumentation.onException(r.activity, e)) {                     throw new RuntimeException(                             "Unable to pause activity "                             + r.intent.getComponent().toShortString()                             + ": " + e.toString(), e);                 }             }             r.paused = true;         }     } else {         // If there was an error, for any reason, tell the activity         // manager to stop us.         try {             ActivityManagerNative.getDefault()                 .finishActivity(r.token, Activity.RESULT_CANCELED, null, false);         } catch (RemoteException ex) {             // Ignore         }     } }           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; } 

在ApplicationThread的scheduleLaunchActivity()中,会调用sendMessage(H.LAUNCH_ACTIVITY, r),Handler收到消息后调用handleLaunchActivity(r, null),真正启动Activity B时,和Activity B相关的一系列操作都在这个方法里。这个方法在正常情况下依次执行了handleConfigurationChanged(null, null),performLaunchActivity(),handleResumeActivity(),分别是Activity B屏幕方向变化和启动的方法。

这里暂时以performLaunchActivity()方法为例。通过反射机制构造一个Activity的实例,然后依次调用activity.attach()添加上下文等信息,activity.setTheme(theme)设置主题,接着由Instrumentation执行mInstrumentation.callActivityOnCreate(),mInstrumentation.callActivityOnRestoreInstanceState(),mInstrumentation.callActivityOnPostCreate()这些方法。

(7)执行 InstrumentationcallActivityOnCreate() 方法,最终走到Activity的activity.performCreate()方法。

public void callActivityOnCreate(Activity activity, Bundle icicle,         PersistableBundle persistentState) {     prePerformCreate(activity);     activity.performCreate(icicle, persistentState);     postPerformCreate(activity); } 

(8)执行 ActivityperformCreate() 方法,最终回调到了 ActivityonCreate() 方法,这就是我们非常熟悉的Activity生命周期方法。

final void performCreate(Bundle icicle, PersistableBundle persistentState) {     onCreate(icicle, persistentState);     mActivityTransitionState.readState(icicle);     performCreateCommon(); }  protected void onCreate(@Nullable Bundle savedInstanceState) {     if (DEBUG_LIFECYCLE) Slog.v(TAG, "onCreate " + this + ": " + savedInstanceState);     if (mLastNonConfigurationInstances != null) {         mFragments.restoreLoaderNonConfig(mLastNonConfigurationInstances.loaders);     }     if (mActivityInfo.parentActivityName != null) {         if (mActionBar == null) {             mEnableDefaultActionBarUp = true;         } else {             mActionBar.setDefaultDisplayHomeAsUpEnabled(true);         }     }     if (savedInstanceState != null) {         Parcelable p = savedInstanceState.getParcelable(FRAGMENTS_TAG);         mFragments.restoreAllState(p, mLastNonConfigurationInstances != null                 ? mLastNonConfigurationInstances.fragments : null);     }     mFragments.dispatchCreate();     getApplication().dispatchActivityCreated(this, savedInstanceState);     if (mVoiceInteractor != null) {         mVoiceInteractor.attachActivity(this);     }     mCalled = true; } 

总结

(1)以上只是以Launch Activity为例做了下分析,实际上Activity的其它操作如finish()和结果回传都是类似的流程走向。大家可以对照源码读读。

(2)重点是文章开头几个类的相互关系。涉及到了Proxy代理模式,IPC进程间通信等知识点。

(3)才疏学浅,如有分析不到位的还请指正。

参考链接

1. http://blog.csdn.net/caowenbin/article/details/6036726

2. http://ju.outofmemory.cn/entry/230403

3. http://blog.csdn.net/stonecao/article/details/6579710

转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » [Android四大组件]Activity启动过程源码分析

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址
分享按钮