Android进阶之深入理解Activity生命周期源码-android activity生命周期

[[419143]]

前言

Activity是一个很重要、很复杂的组件，他的启动不像我们平时直接new一个对象就完事了，他需要经历一系列的初始化。例如"刚创建状态"，“后台状态”，“可见状态”等等;

当我们在界面之间进行切换的时候，activity也会在多种状态之间进行切换，可见或者不可见状态、前台或者后台状态。当Activity在不同的状态之间切换时，会回调不同的生命周期方法;

今天我们就来总结下Activity生命周期;

一、生命周期

Activity个状态生命周期流程图

由上图可知：

1.Starting -> Running，执行的生命周期顺序 onCreate()->onstart()->onResume()，

此activity所处于任务栈的top中，可以与用户进行交互。

2.Running -> Paused ，执行Activity生命周期中的onPause()，

该Activity已失去了焦点但仍然是可见的状态(包括部分可见)。就比如弹出DialogActivity

3.Paused -> Running,执行Activity生命周期中的onResume()，

此情况用户操作[home键]，然后重新回到当前activity界面，还有就是关闭DialogActivity

1.Activity1 跳转至 Activity2 执行的生命周期：

Activity1:onPause 
Activity2:onCreate 
Activity2:onStart 
Activity2:onResume 
Activity1:onStop

2.Activity2回到Activity1 执行的生命周期：

Activity2:onPause 
Activity1:onRestart 
Activity1:onStart 
Activity1:onResume 
Activity2:onStop 
Activity2:onDestory

3. LifeCycleActivity弹出DialogActivity 执行的生命周期：

LifeCycleActivity:onPause 
DialogActivity:onCreate 
DialogActivity:onStart 
DialogActivity:onResume 
值得注意的是：这里 LifeCycleActivity不会进入onStop，因为弹出DialogActivity时LifeCycleActivity还处于可见

4.DialogActivity返回键到LifeCycleActivity执行的生命周期：

DialogActivity:onPause 
LifeCycleActivity:onResume 
DialogActivity:onStop 
DialogActivity:onDestroy

5.LifeCycleActivity旋转屏幕执行的生命周期：

LifeCycleActivity:onPause 
LifeCycleActivity:onStop 
LifeCycleActivity:onDestroy 
LifeCycleActivity:onCreate 
LifeCycleActivity:onStart 
LifeCycleActivity:onResume 
这里相当于重新创建了Activity

6.Activity横竖屏切换状态保存：

当前ViewPager有三个Fragment，在竖屏时选择的Fragment为第二个，如何在切换横屏后选中第二个Fragment并且Fragment保持之前的状态?

由于onCreate可以拿到保持状态的Bundle，而每次onPause以及onStop都会回调onSaveInstanceState(Bundle outState)方法;

所以可在该方法就行保存状态，大体代码如下：

@Override 
protected void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState); 
        setContentView(R.layout.activity_main); 
        // 初始化主页fragment 
        if (savedInstanceState != null) { 
            //系统回收后重新进入当前页面恢复数据 
            resumeFragment(getSupportFragmentManager(), savedInstanceState); 
            resumeIndex(savedInstanceState); 
            showSelectFragmentOnly(getSupportFragmentManager()); 
            mTabLayout.setCurrentItem(mIndex); 
        } else { 
            //正常初始化 
            mTabLayout.setCurrentItem(0); 
            showFragment(getSupportFragmentManager(), 0); 
            mIndex=0; 
        } 
    } 
   private void resumeFragment(FragmentManager fragmentManager, Bundle savedInstanceState) { 
        Fragment[] fragments = new Fragment[fragmentTab.length]; 
        for (int i = 0; i < fragments.length; i++) { 
            fragments[i] = fragmentManager.getFragment(savedInstanceState, fragmentTab[i].getSimpleName()); 
        } 
        mFragments = fragments; 
    } 
    private void resumeIndex(Bundle savedInstanceState) { 
        mIndex = savedInstanceState.getInt(CURRENT_INDEX, 0); 
    } 
  @Override 
    protected void onSaveInstanceState(Bundle outState) { 
        super.onSaveInstanceState(outState); 
        for (Fragment fragment : mFragments) { 
            if (fragment != null) { 
                getSupportFragmentManager().putFragment(outState, fragment.getClass().getName(), fragment); 
            } 
        } 
        outState.putInt(CURRENT_INDEX, mIndex); 
    }

下图概括了android生命周期的各个环节，描述了activity从生成到销毁的过程

创建：onCreate():
|---可用于初始化工作，如setContentView界面资源、初始化数据
启动：onStart():
|---可见但无法交互
恢复:onResume():
|---恢复播放动画、音乐、视频等
暂停:onPause():
|---可做数据存储、停止动画、音乐、视频等
停止:onStop():
|---此时Activity不可见,可做视情况做些重量级回收工作，避免被Killed
销毁:onDestroy():
|---回收工作、资源释放
重现：onRestart():
|---可做一些恢复工作

二、Activity基本结构

一个应用程序通常由多个Activity组成，那么在应用程序中肯定需要一个容器来盛放这些Activity，必要时通过该容器找到对应的Activity，并进行相关操作。上一篇文章已经讲过一个应用程序对应一个ActivityThread，所以自然而然地该容器是ActivityThread在负责维护，这个容器叫做mActivities，是一个数组，里面的每一项叫做ActivityRecord，一个ActivityRecord对应一个Activity。
以上仅仅是应用级别的管理容器，但是很多场景下，系统需要找到某一个特定的Activity，并下发相关数据比如事件分发。所以还必须在系统层面再维护一个容器，这个容器存放在Activity Manager Service,对应的容器叫做mHistory,对应的每一项叫做HistroyRecord。
每个Activity必须依靠在进程中，每个进程对应一个AMS中的ProcessRecord，通过这个ProcessRecord可以找到对应的应用的所有Activity，同时还提供了与Activity联系的接口IActivityThread。
所以整个Activity的管理框架如下图所示：

三.生命周期源码详解

在Launch Activity时，AMS将对应的HistoryRecord作为token传递到客服端和客服端的Activity建立联系。在AMS中Activity状态变化时，将通过该联系找到客服端的Activity，从而将消息或者动作传递应用程序面对的接口：xxxActivity。整个Activity的启动过程大致可以分为以下几个步骤：

发起startActivity(intent)请求

AMS接收到请求后，创建一个HistroyRecord对象，并将该对象放到mHistory数组中

调用app.thread.scheduleLaunchActivity()

AMS创建ActivityRecord对象，将创建的Activity放入到ActivityRecord，再将其放入到mActivities

发起Activity的onCreate()方法

1、Activty是如何创建?ActivityThread 便是这关键

public final class ActivityThread { 
   Instrumentation mInstrumentation; 
    ...... 
    final ApplicationThread mAppThread = new ApplicationThread(); 
   // Looper类创建 
    final Looper mLooper = Looper.myLooper(); 
   // H是继承Handler类 在AcivityThread创建时就创建了 
    final H mH = new H(); 
   ...... 
}

H类源码如下：

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; 
                case RELAUNCH_ACTIVITY: { 
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart"); 
                    ActivityClientRecord r = (ActivityClientRecord)msg.obj; 
                    handleRelaunchActivity(r); 
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 
                } break; 
                case PAUSE_ACTIVITY: { 
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause"); 
                    SomeArgs args = (SomeArgs) msg.obj; 
                    handlePauseActivity((IBinder) args.arg1, false, 
                            (args.argi1 & USER_LEAVING) != 0, args.argi2, 
                            (args.argi1 & DONT_REPORT) != 0, args.argi3); 
                    maybeSnapshot(); 
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 
                } break; 
                case PAUSE_ACTIVITY_FINISHING: { 
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause"); 
                    SomeArgs args = (SomeArgs) msg.obj; 
                    handlePauseActivity((IBinder) args.arg1, true, (args.argi1 & USER_LEAVING) != 0, 
                            args.argi2, (args.argi1 & DONT_REPORT) != 0, args.argi3); 
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 
                } break; 
                case STOP_ACTIVITY_SHOW: { 
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop"); 
                    SomeArgs args = (SomeArgs) msg.obj; 
                    handleStopActivity((IBinder) args.arg1, true, args.argi2, args.argi3); 
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 
                } break; 
                case STOP_ACTIVITY_HIDE: { 
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop"); 
                    SomeArgs args = (SomeArgs) msg.obj; 
                    handleStopActivity((IBinder) args.arg1, false, args.argi2, args.argi3); 
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 
                } break; 
                case SHOW_WINDOW: 
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityShowWindow"); 
                    handleWindowVisibility((IBinder)msg.obj, true); 
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 
                    break; 
                case HIDE_WINDOW: 
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityHideWindow"); 
                    handleWindowVisibility((IBinder)msg.obj, false); 
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 
                    break; 
                case RESUME_ACTIVITY: 
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityResume"); 
                    SomeArgs args = (SomeArgs) msg.obj; 
                    handleResumeActivity((IBinder) args.arg1, true, args.argi1 != 0, true, 
                            args.argi3, "RESUME_ACTIVITY"); 
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 
                    break; 
                case SEND_RESULT: 
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityDeliverResult"); 
                    handleSendResult((ResultData)msg.obj); 
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 
                    break; 
                case DESTROY_ACTIVITY: 
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityDestroy"); 
                    handleDestroyActivity((IBinder)msg.obj, msg.arg1 != 0, 
                            msg.arg2, false); 
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 
                    break; 
......... 
        } 
}

那么H类handleMessage是怎么被调用的呢?其实是通过ApplicationThread的scheduleLaunchActivity来完成的，这里ApplicationThread是ActivtyThread的内部类

ApplicationThread部分源码如下：

private class ApplicationThread extends IApplicationThread.Stub { 
        ........省略...... 
        public final void schedulePauseActivity(IBinder token, boolean finished, 
                boolean userLeaving, int configChanges, boolean dontReport) { 
            int seq = getLifecycleSeq(); 
            if (DEBUG_ORDER) Slog.d(TAG, "pauseActivity " + ActivityThread.this 
                    + " operation received seq: " + seq); 
            sendMessage( 
                    finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY, 
                    token, 
                    (userLeaving ? USER_LEAVING : 0) | (dontReport ? DONT_REPORT : 0), 
                    configChanges, 
                    seq); 
        } 
        public final void scheduleStopActivity(IBinder token, boolean showWindow, 
                int configChanges) { 
            int seq = getLifecycleSeq(); 
            if (DEBUG_ORDER) Slog.d(TAG, "stopActivity " + ActivityThread.this 
                    + " operation received seq: " + seq); 
            sendMessage( 
                showWindow ? H.STOP_ACTIVITY_SHOW : H.STOP_ACTIVITY_HIDE, 
                token, 0, configChanges, seq); 
        } 
        public final void scheduleWindowVisibility(IBinder token, boolean showWindow) { 
            sendMessage( 
                showWindow ? H.SHOW_WINDOW : H.HIDE_WINDOW, 
                token); 
        } 
        public final void scheduleSleeping(IBinder token, boolean sleeping) { 
            sendMessage(H.SLEEPING, token, sleeping ? 1 : 0); 
        } 
        public final void scheduleResumeActivity(IBinder token, int processState, 
                boolean isForward, Bundle resumeArgs) { 
            int seq = getLifecycleSeq(); 
            if (DEBUG_ORDER) Slog.d(TAG, "resumeActivity " + ActivityThread.this 
                    + " operation received seq: " + seq); 
            updateProcessState(processState, false); 
            sendMessage(H.RESUME_ACTIVITY, token, isForward ? 1 : 0, 0, seq); 
        } 
        public final void scheduleSendResult(IBinder token, List<ResultInfo> results) { 
            ResultData res = new ResultData(); 
            res.token = token; 
            res.results = results; 
            sendMessage(H.SEND_RESULT, res); 
        } 
        // AMS通过调用此方法启动Activity 
        @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); 
        } 
      ........省略...... 
}

2、那么ActivtyThread是如何初始化的?

通过主入口函数main方法进行初始化：

public static void main(String[] args) { 
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain"); 
        SamplingProfilerIntegration.start(); 
        CloseGuard.setEnabled(false); 
        Environment.initForCurrentUser(); 
        EventLogger.setReporter(new EventLoggingReporter()); 
        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId()); 
        TrustedCertificateStore.setDefaultUserDirectory(configDir); 
        Process.setArgV0("<pre-initialized>"); 
        Looper.prepareMainLooper(); 
// 初始化ActivityThread  
        ActivityThread thread = new ActivityThread(); 
        thread.attach(false); 
        if (sMainThreadHandler == null) { 
            sMainThreadHandler = thread.getHandler(); 
        } 
        if (false) { 
            Looper.myLooper().setMessageLogging(new 
                    LogPrinter(Log.DEBUG, "ActivityThread")); 
        } 
        // End of event ActivityThreadMain. 
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 
        Looper.loop(); 
        throw new RuntimeException("Main thread loop unexpectedly exited"); 
    }

3、ApplicationThread的scheduleLaunchActivity是如何被调用的?

在上述代码中我们看到ActivtyThread初始化后调用了attach方法

private void attach(boolean system) { 
        sCurrentActivityThread = this; 
        mSystemThread = system; 
        if (!system) { 
            ViewRootImpl.addFirstDrawHandler(new Runnable() { 
                @Override 
                public void run() { 
                    ensureJitEnabled(); 
                } 
            }); 
            android.ddm.DdmHandleAppName.setAppName("<pre-initialized>", 
                                                    UserHandle.myUserId()); 
            RuntimeInit.setApplicationObject(mAppThread.asBinder()); 
            final IActivityManager mgr = ActivityManager.getService(); 
            try { 
// 调用scheduleLaunchActivity的关键代码 
                mgr.attachApplication(mAppThread); 
            } catch (RemoteException ex) { 
                throw ex.rethrowFromSystemServer(); 
            } 
            // Watch for getting close to heap limit. 
            BinderInternal.addGcWatcher(new Runnable() { 
                @Override public void run() { 
                    if (!mSomeActivitiesChanged) { 
                        return; 
                    } 
                    Runtime runtime = Runtime.getRuntime(); 
                    long dalvikMax = runtime.maxMemory(); 
                    long dalvikUsed = runtime.totalMemory() - runtime.freeMemory(); 
                    if (dalvikUsed > ((3*dalvikMax)/4)) { 
                        if (DEBUG_MEMORY_TRIM) Slog.d(TAG, "Dalvik max=" + (dalvikMax/1024) 
                                + " total=" + (runtime.totalMemory()/1024) 
                                + " used=" + (dalvikUsed/1024)); 
                        mSomeActivitiesChanged = false; 
                        try { 
                            mgr.releaseSomeActivities(mAppThread); 
                        } catch (RemoteException e) { 
                            throw e.rethrowFromSystemServer(); 
                        } 
                    } 
                } 
            }); 
        } else { 
         // 这里是系统服务初始化的，在SystemServer类中main方法进行调用 
            android.ddm.DdmHandleAppName.setAppName("system_process", 
                    UserHandle.myUserId()); 
            try { 
                mInstrumentation = new Instrumentation(); 
                ContextImpl context = ContextImpl.createAppContext( 
                        this, getSystemContext().mPackageInfo); 
                mInitialApplication = context.mPackageInfo.makeApplication(true, null); 
                mInitialApplication.onCreate(); 
            } catch (Exception e) { 
                throw new RuntimeException( 
                        "Unable to instantiate Application():" + e.toString(), e); 
            } 
        } 
        // add dropbox logging to libcore 
        DropBox.setReporter(new DropBoxReporter()); 
        ViewRootImpl.ConfigChangedCallback configChangedCallback 
                = (Configuration globalConfig) -> { 
            synchronized (mResourcesManager) { 
                // We need to apply this change to the resources immediately, because upon returning 
                // the view hierarchy will be informed about it. 
                if (mResourcesManager.applyConfigurationToResourcesLocked(globalConfig, 
                        null /* compat */)) { 
                    updateLocaleListFromAppContext(mInitialApplication.getApplicationContext(), 
                            mResourcesManager.getConfiguration().getLocales()); 
                    // This actually changed the resources! Tell everyone about it. 
                    if (mPendingConfiguration == null 
                            || mPendingConfiguration.isOtherSeqNewer(globalConfig)) { 
                        mPendingConfiguration = globalConfig; 
                        sendMessage(H.CONFIGURATION_CHANGED, globalConfig); 
                    } 
                } 
            } 
        }; 
        ViewRootImpl.addConfigCallback(configChangedCallback); 
    }

上述代码中IActivityManager是一个接口而他的实现类就是大名鼎鼎的

ActivityManagerService(AMS)，我们来看AMS中对attachApplication的实现: 
    @Override 
    public final void attachApplication(IApplicationThread thread) { 
// ApplicationThread 实现了IApplicationThread的接口 
        synchronized (this) { 
            int callingPid = Binder.getCallingPid(); 
            final long origId = Binder.clearCallingIdentity(); 
            attachApplicationLocked(thread, callingPid); 
            Binder.restoreCallingIdentity(origId); 
        } 
    }

attachApplicationLocked方法中调用了ActivityStackSupervisor中的attachApplicationLocked方法，而该方法中调用了ApplicationThread中scheduleLaunchActivity，有兴趣的可以去看下源码。

我们可以发现其实不管是scheduleLaunchActivity还是其他的schedule...方法都调用了ApplicationThread中的sendMessage方法，该方法如下：

private void sendMessage(int what, Object obj) { 
        sendMessage(what, obj, 0, 0, false); 
    } 
    private void sendMessage(int what, Object obj, int arg1) { 
        sendMessage(what, obj, arg1, 0, false); 
    } 
    private void sendMessage(int what, Object obj, int arg1, int arg2) { 
        sendMessage(what, obj, arg1, arg2, false); 
    } 
    private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) { 
        if (DEBUG_MESSAGES) Slog.v( 
            TAG, "SCHEDULE " + what + " " + mH.codeToString(what) 
            + ": " + arg1 + " / " + obj); 
        Message msg = Message.obtain(); 
        msg.what = what; 
        msg.obj = obj; 
        msg.arg1 = arg1; 
        msg.arg2 = arg2; 
        if (async) { 
            msg.setAsynchronous(true); 
        } 
        mH.sendMessage(msg); 
    }

我们方法转了一圈依旧回到了handler.sendMessage()方法，可见handler在Android中的重要性;

4、如何处理Handler发送的消息呢?

通过handleMessage进行处理，所有的生命周期其实都是通过该方法处理的，源码如下：

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; 
      } 
......省略..... 
}

Looper会循环获取messageQueue队列中的message，并通过dispatchMessage多消息进行分发，源码如下：

public void dispatchMessage(Message msg) { 
       if (msg.callback != null) { 
           handleCallback(msg); 
       } else { 
           if (mCallback != null) { 
               if (mCallback.handleMessage(msg)) { 
                   return; 
               } 
           } 
/ 这里其实是调用了H类的handleMessage方法 
           handleMessage(msg); 
       } 
   }

上述代码可以看到handleMessage中的handleLaunchActivity是关键，handleLaunchActivity代码如下：

 private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) { 
        unscheduleGcIdler(); 
        mSomeActivitiesChanged = true; 
        if (r.profilerInfo != null) { 
            mProfiler.setProfiler(r.profilerInfo); 
            mProfiler.startProfiling(); 
        } 
        handleConfigurationChanged(null, null); 
        if (localLOGV) Slog.v( 
            TAG, "Handling launch of " + r); 
        WindowManagerGlobal.initialize(); 
// 在这里创建了application以及activity 
        Activity a = performLaunchActivity(r, customIntent); 
        if (a != null) { 
            r.createdConfig = new Configuration(mConfiguration); 
            reportSizeConfigurations(r); 
            Bundle oldState = r.state; 
            handleResumeActivity(r.token, false, r.isForward, 
                    !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason); 
            if (!r.activity.mFinished && r.startsNotResumed) { 
                performPauseActivityIfNeeded(r, reason); 
                if (r.isPreHoneycomb()) { 
                    r.state = oldState; 
                } 
            } 
        } else { 
            try { 
                ActivityManager.getService() 
                    .finishActivity(r.token, Activity.RESULT_CANCELED, null, 
                            Activity.DONT_FINISH_TASK_WITH_ACTIVITY); 
            } catch (RemoteException ex) { 
                throw ex.rethrowFromSystemServer(); 
            } 
        } 
    } 
 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); 
        } 
// 创建context 
        ContextImpl appContext = createBaseContextForActivity(r); 
        Activity activity = null; 
        try { 
            java.lang.ClassLoader cl = appContext.getClassLoader(); 
// activty的创建  
            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的创建 
            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) { 
// 从配置文件获取label作为Activity默认title 
                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.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; 
                if (r.isPersistable()) { 
// 触发onCreate回调 
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState); 
                } else { 
// 触发onCreate回调 
                    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) { 
// 其实都是调用了Activity的onPostCreate方法，该方法调用了onTitleChanged方法，用于设置title栏 
                        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; 
    }

上述代码中可以看到在performLaunchActivity中创建了上下文Context，Application，以及Activity，而后通过Activity的attach方法为Context赋值并且将Activity与Window绑定，有兴趣的可以去看下其实是为ContextWrapper中的mBase对象进行了赋值，而且Activity的attach方法中实例化了Window对象，并且设定了UI线程为当前线程，这里就不做讲解，贴出attach的源码：

final void attach(Context context, ActivityThread aThread, 
           Instrumentation instr, IBinder token, int ident, 
           Application application, Intent intent, ActivityInfo info, 
           CharSequence title, Activity parent, String id, 
           NonConfigurationInstances lastNonConfigurationInstances, 
           Configuration config, String referrer, IVoiceInteractor voiceInteractor, 
           Window window, ActivityConfigCallback activityConfigCallback) { 
       attachBaseContext(context); 
       mFragments.attachHost(null /*parent*/); 
       mWindow = new PhoneWindow(this, window, activityConfigCallback); 
       mWindow.setWindowControllerCallback(this); 
       mWindow.setCallback(this); 
       mWindow.setOnWindowDismissedCallback(this); 
       mWindow.getLayoutInflater().setPrivateFactory(this); 
       if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) { 
           mWindow.setSoftInputMode(info.softInputMode); 
       } 
       if (info.uiOptions != 0) { 
           mWindow.setUiOptions(info.uiOptions); 
       } 
       mUiThread = Thread.currentThread(); 
       mMainThread = aThread; 
       mInstrumentation = instr; 
       mToken = token; 
       mIdent = ident; 
       mApplication = application; 
       mIntent = intent; 
       mReferrer = referrer; 
       mComponent = intent.getComponent(); 
       mActivityInfo = info; 
       mTitle = title; 
       mParent = parent; 
       mEmbeddedID = id; 
       mLastNonConfigurationInstances = lastNonConfigurationInstances; 
       if (voiceInteractor != null) { 
           if (lastNonConfigurationInstances != null) { 
               mVoiceInteractor = lastNonConfigurationInstances.voiceInteractor; 
           } else { 
               mVoiceInteractor = new VoiceInteractor(voiceInteractor, this, this, 
                       Looper.myLooper()); 
           } 
       } 
       mWindow.setWindowManager( 
               (WindowManager)context.getSystemService(Context.WINDOW_SERVICE), 
               mToken, mComponent.flattenToString(), 
               (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0); 
       if (mParent != null) { 
           mWindow.setContainer(mParent.getWindow()); 
       } 
       mWindowManager = mWindow.getWindowManager(); 
       mCurrentConfig = config; 
       mWindow.setColorMode(info.colorMode); 
   }

在所有生命周期回调中，都是调用了Instrumentation中的方法，而Instrumentation的调用都是通过Handler发送消息触发H函数的handleMessage方法来进行的，然后Instrumentation中的方法再去调用Activity中的生命周期方法，其实我们常用的onActivityResult回调都是通过handleMessage去分发的。Instrumentation部分代码如下

// 触发onCreate 
  public void callActivityOnCreate(Activity activity, Bundle icicle, 
            PersistableBundle persistentState) { 
        prePerformCreate(activity); 
        activity.performCreate(icicle, persistentState); 
        postPerformCreate(activity); 
    } 
// 触发onResume 
public void callActivityOnResume(Activity activity) { 
        activity.mResumed = true; 
        activity.onResume(); 
        if (mActivityMonitors != null) { 
            synchronized (mSync) { 
                final int N = mActivityMonitors.size(); 
                for (int i=0; i<N; i++) { 
                    final ActivityMonitor am = mActivityMonitors.get(i); 
                    am.match(activity, activity, activity.getIntent()); 
                } 
            } 
        } 
    }

总结：

创建一个activity会依次执行onCreate, onStart, onResume
从一个activity启动另一个activity会先调用当前activity的onResume，然后在创建并显示要启动的activity。
从非透明activity返回的时候会先调用当前的onPause，然后调用前一个activitiy的onRestart、onStart、onResme，然后在调用这个Activity的onStop，onDestroy。
从透明的activity返回的时候会先调用当前activity的onPause，然后调用前一个activity的onResume，然后调用这个透明activity的onStop，onDestroy。
透明的Activity比较特殊，他会让别的activity的一些生命周期不被调用比如onStop等待。
onResume方法里不能有太耗时的操作，因为当启动另一个activity的时候，当前的onResume没有返回不会去创建要启动的那个activity
Activity启动过程会经历两次跨进程，从App进程到AMS，从AMS再到APP进程，实际情况要远比这复杂的多;

本文转载自微信公众号「 Android开发编程」